diff --git a/runtimes/google/ipc/client.go b/runtimes/google/ipc/client.go
index a246e1f..2788afb 100644
--- a/runtimes/google/ipc/client.go
+++ b/runtimes/google/ipc/client.go
@@ -27,6 +27,7 @@
 	verror "veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 	"veyron.io/veyron/veyron2/vom"
+	"veyron.io/veyron/veyron2/vom2"
 	"veyron.io/veyron/veyron2/vtrace"
 )
 
@@ -52,6 +53,9 @@
 	errSystemRetry   = verror.Register(pkgPath+".sysErrorRetryConnection", verror.RetryConnection, "{:3:}")
 	errSystemNoRetry = verror.Register(pkgPath+".sysErrorNoRetry", verror.NoRetry, "{:3:}")
 
+	errVomEncoder = verror.Register(pkgPath+".vomEncoder", verror.NoRetry, "failed to create vom encoder {:3}")
+	errVomDecoder = verror.Register(pkgPath+".vomDecoder", verror.NoRetry, "failed to create vom decoder {:3}")
+
 	errRequestEncoding = verror.Register(pkgPath+".requestEncoding", verror.NoRetry, "failed to encode request {3}{:4}")
 
 	errDischargeEncoding = verror.Register(pkgPath+".dischargeEncoding", verror.NoRetry, "failed to encode discharge {3}{:4}")
@@ -453,7 +457,10 @@
 			//
 			// We must ensure that all flows other than r.flow are closed.
 			go cleanupTryCall(r, responses, ch)
-			fc := newFlowClient(ctx, serverB, r.flow, c.dc)
+			fc, err := newFlowClient(ctx, serverB, r.flow, c.dc)
+			if err != nil {
+				return nil, err.(verror.E)
+			}
 
 			if doneChan := ctx.Done(); doneChan != nil {
 				go func() {
@@ -596,8 +603,8 @@
 // flow that's already connected to the server.
 type flowClient struct {
 	ctx      context.T    // context to annotate with call details
-	dec      *vom.Decoder // to decode responses and results from the server
-	enc      *vom.Encoder // to encode requests and args to the server
+	dec      vomDecoder   // to decode responses and results from the server
+	enc      vomEncoder   // to encode requests and args to the server
 	server   []string     // Blessings bound to the server that authorize it to receive the IPC request from the client.
 	flow     stream.Flow  // the underlying flow
 	response ipc.Response // each decoded response message is kept here
@@ -614,8 +621,8 @@
 var _ ipc.Call = (*flowClient)(nil)
 var _ ipc.Stream = (*flowClient)(nil)
 
-func newFlowClient(ctx context.T, server []string, flow stream.Flow, dc vc.DischargeClient) *flowClient {
-	return &flowClient{
+func newFlowClient(ctx context.T, server []string, flow stream.Flow, dc vc.DischargeClient) (*flowClient, error) {
+	fc := &flowClient{
 		ctx:    ctx,
 		dec:    vom.NewDecoder(flow),
 		enc:    vom.NewEncoder(flow),
@@ -623,6 +630,19 @@
 		flow:   flow,
 		dc:     dc,
 	}
+	if vom2.IsEnabled() {
+		var err error
+		if fc.enc, err = vom2.NewBinaryEncoder(flow); err != nil {
+			return nil, fc.close(badProtocol(fc.ctx, verror.Make(errVomEncoder, fc.ctx, err)))
+		}
+		if fc.dec, err = vom2.NewDecoder(flow); err != nil {
+			return nil, fc.close(badProtocol(fc.ctx, verror.Make(errVomDecoder, fc.ctx, err)))
+		}
+	} else {
+		fc.dec = vom.NewDecoder(flow)
+		fc.enc = vom.NewEncoder(flow)
+	}
+	return fc, nil
 }
 
 func (fc *flowClient) close(verr verror.E) verror.E {
diff --git a/runtimes/google/ipc/flow_test.go b/runtimes/google/ipc/flow_test.go
deleted file mode 100644
index c44b050..0000000
--- a/runtimes/google/ipc/flow_test.go
+++ /dev/null
@@ -1,167 +0,0 @@
-package ipc
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"testing"
-
-	"veyron.io/veyron/veyron/lib/testutil"
-	tsecurity "veyron.io/veyron/veyron/lib/testutil/security"
-
-	"veyron.io/veyron/veyron2/ipc"
-	"veyron.io/veyron/veyron2/naming"
-	"veyron.io/veyron/veyron2/security"
-	"veyron.io/veyron/veyron2/verror"
-)
-
-func init() { testutil.Init() }
-
-// newTestFlows returns the two ends of a bidirectional flow.  Each end has its
-// own bookkeeping, to allow testing of method calls.
-func newTestFlows() (*testFlow, *testFlow) {
-	var (
-		p0, p1               = tsecurity.NewPrincipal("p0"), tsecurity.NewPrincipal("p1")
-		blessing0, blessing1 = p0.BlessingStore().Default(), p1.BlessingStore().Default()
-		b0, b1               = new(bytes.Buffer), new(bytes.Buffer)
-	)
-	return &testFlow{r: b0, w: b1, p: p0, lb: blessing0, rb: blessing1}, &testFlow{r: b1, w: b0, p: p1, lb: blessing1, rb: blessing0}
-}
-
-type testFlow struct {
-	r, w          *bytes.Buffer
-	p             security.Principal
-	lb, rb        security.Blessings
-	numCloseCalls int
-	errClose      error
-}
-
-func (f *testFlow) Read(b []byte) (int, error)                    { return f.r.Read(b) }
-func (f *testFlow) Write(b []byte) (int, error)                   { return f.w.Write(b) }
-func (*testFlow) LocalEndpoint() naming.Endpoint                  { return nil }
-func (*testFlow) RemoteEndpoint() naming.Endpoint                 { return nil }
-func (f *testFlow) LocalPrincipal() security.Principal            { return f.p }
-func (f *testFlow) LocalBlessings() security.Blessings            { return f.lb }
-func (f *testFlow) RemoteBlessings() security.Blessings           { return f.rb }
-func (*testFlow) RemoteDischarges() map[string]security.Discharge { return nil }
-func (*testFlow) SetDeadline(<-chan struct{})                     {}
-func (*testFlow) IsClosed() bool                                  { return false }
-func (*testFlow) Closed() <-chan struct{}                         { return nil }
-func (*testFlow) Cancel()                                         {}
-
-func (f *testFlow) Close() error {
-	f.numCloseCalls++
-	return f.errClose
-}
-
-// testDisp implements a simple test dispatcher, that uses the newInvoker
-// factory function to create an underlying invoker on each Lookup.
-type testDisp struct {
-	newInvoker func(suffix string) ipc.Invoker
-}
-
-func (td testDisp) Lookup(suffix string) (interface{}, security.Authorizer, error) {
-	return td.newInvoker(suffix), testServerAuthorizer{}, nil
-}
-
-// closureInvoker serves a method with no user args or results:
-//    func(ipc.ServerCall) error
-type closureInvoker struct{ suffix string }
-
-func newClosureInvoker(suffix string) ipc.Invoker {
-	return closureInvoker{suffix}
-}
-
-func (closureInvoker) Prepare(method string, numArgs int) (argptrs, tags []interface{}, err error) {
-	return nil, nil, nil
-}
-func (inv closureInvoker) Invoke(method string, call ipc.ServerCall, argptrs []interface{}) (results []interface{}, err error) {
-	if inv.suffix == "" {
-		return nil, nil
-	}
-	return nil, errors.New(inv.suffix)
-}
-func (closureInvoker) Signature(ctx ipc.ServerContext) ([]ipc.InterfaceSig, error) {
-	return nil, nil
-}
-func (closureInvoker) MethodSignature(ctx ipc.ServerContext, method string) (ipc.MethodSig, error) {
-	return ipc.MethodSig{}, nil
-}
-func (closureInvoker) VGlob() *ipc.GlobState {
-	return nil
-}
-
-// echoInvoker serves a method that takes a string and echoes it:
-//    func(_ ServerCall, arg string) (string, error)
-type echoInvoker struct{ suffix string }
-
-func newEchoInvoker(suffix string) ipc.Invoker {
-	return echoInvoker{suffix}
-}
-
-func (echoInvoker) Prepare(method string, numArgs int) (argptrs, tags []interface{}, err error) {
-	var arg string
-	return []interface{}{&arg}, nil, nil
-}
-func (inv echoInvoker) Invoke(method string, call ipc.ServerCall, argptrs []interface{}) (results []interface{}, err error) {
-	result := fmt.Sprintf("method:%q,suffix:%q,arg:%q", method, inv.suffix, *argptrs[0].(*string))
-	return []interface{}{result}, nil
-}
-func (echoInvoker) Signature(ctx ipc.ServerContext) ([]ipc.InterfaceSig, error) {
-	return nil, nil
-}
-func (echoInvoker) MethodSignature(ctx ipc.ServerContext, method string) (ipc.MethodSig, error) {
-	return ipc.MethodSig{}, nil
-}
-func (echoInvoker) VGlob() *ipc.GlobState {
-	return nil
-}
-
-func TestFlowClientServer(t *testing.T) {
-	type v []interface{}
-	type testcase struct {
-		suffix string
-		method string
-		args   []interface{}
-		expect []interface{}
-		err    error
-	}
-	tests := []testcase{
-		{"echo", "A", v{""}, v{`method:"A",suffix:"echo",arg:""`}, nil},
-		{"echo", "B", v{"foo"}, v{`method:"B",suffix:"echo",arg:"foo"`}, nil},
-		{"echo/abc", "C", v{""}, v{`method:"C",suffix:"echo/abc",arg:""`}, nil},
-		{"echo/abc", "D", v{"foo"}, v{`method:"D",suffix:"echo/abc",arg:"foo"`}, nil},
-	}
-	name := func(t testcase) string {
-		return fmt.Sprintf("%s.%s%v", t.suffix, t.method, t.args)
-	}
-
-	ipcServer := &server{
-		ctx:   testContext(),
-		disp:  testDisp{newEchoInvoker},
-		stats: newIPCStats(""),
-	}
-	for _, test := range tests {
-		clientFlow, serverFlow := newTestFlows()
-		client := newFlowClient(testContext(), []string{"p0"}, clientFlow, nil)
-		server := newFlowServer(serverFlow, ipcServer)
-		err := client.start(test.suffix, test.method, test.args, 0, nil)
-		if err != nil {
-			t.Errorf("%s client.start unexpected error: %v", name(test), err)
-		}
-		if err := server.serve(); !verror.Equal(err, test.err) {
-			t.Errorf("%s server.server returned %v want %v", name(test), err, test.err)
-		}
-		results := makeResultPtrs(test.expect)
-		if err := client.Finish(results...); !verror.Equal(err, test.err) {
-			t.Errorf(`%s client.Finish got error "%v", want "%v"`, name(test), err, test.err)
-		}
-		checkResultPtrs(t, name(test), results, test.expect)
-		if clientFlow.numCloseCalls != 1 {
-			t.Errorf("%s got %d client close calls, want 1", name(test), clientFlow.numCloseCalls)
-		}
-		if serverFlow.numCloseCalls != 1 {
-			t.Errorf("%s got %d server close calls, want 1", name(test), serverFlow.numCloseCalls)
-		}
-	}
-}
diff --git a/runtimes/google/ipc/full_test.go b/runtimes/google/ipc/full_test.go
index 02c2633..a5be1c5 100644
--- a/runtimes/google/ipc/full_test.go
+++ b/runtimes/google/ipc/full_test.go
@@ -25,7 +25,6 @@
 	"veyron.io/veyron/veyron2/vdl/vdlutil"
 	verror "veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
-	"veyron.io/veyron/veyron2/vom"
 
 	"veyron.io/veyron/veyron/lib/netstate"
 	"veyron.io/veyron/veyron/lib/testutil"
@@ -374,7 +373,7 @@
 func TestRPCServerAuthorization(t *testing.T) {
 	const (
 		vcErr   = "VC handshake failed"
-		nameErr = "does not match the provided pattern"
+		nameErr = "do not match pattern"
 	)
 	var (
 		pprovider, pclient, pserver = tsecurity.NewPrincipal("root"), tsecurity.NewPrincipal(), tsecurity.NewPrincipal()
@@ -1605,5 +1604,5 @@
 
 func init() {
 	testutil.Init()
-	vom.Register(fakeTimeCaveat(0))
+	vdlutil.Register(fakeTimeCaveat(0))
 }
diff --git a/runtimes/google/ipc/server.go b/runtimes/google/ipc/server.go
index 78c638f..ca392b5 100644
--- a/runtimes/google/ipc/server.go
+++ b/runtimes/google/ipc/server.go
@@ -20,6 +20,7 @@
 	"veyron.io/veyron/veyron2/verror"
 	"veyron.io/veyron/veyron2/vlog"
 	"veyron.io/veyron/veyron2/vom"
+	"veyron.io/veyron/veyron2/vom2"
 	"veyron.io/veyron/veyron2/vtrace"
 
 	"veyron.io/veyron/veyron/lib/netstate"
@@ -432,12 +433,17 @@
 		}
 		calls.Add(1)
 		go func(flow stream.Flow) {
-			if err := newFlowServer(flow, s).serve(); err != nil {
+			defer calls.Done()
+			fs, err := newFlowServer(flow, s)
+			if err != nil {
+				vlog.Errorf("newFlowServer on %v failed: %v", ln, err)
+				return
+			}
+			if err := fs.serve(); err != nil {
 				// TODO(caprita): Logging errors here is too spammy. For example, "not
 				// authorized" errors shouldn't be logged as server errors.
 				vlog.Errorf("Flow serve on %v failed: %v", ln, err)
 			}
-			calls.Done()
 		}(flow)
 	}
 }
@@ -627,14 +633,23 @@
 	return firstErr
 }
 
+// TODO(toddw): Remove these interfaces after the vom2 transition.
+type vomEncoder interface {
+	Encode(v interface{}) error
+}
+
+type vomDecoder interface {
+	Decode(v interface{}) error
+}
+
 // flowServer implements the RPC server-side protocol for a single RPC, over a
 // flow that's already connected to the client.
 type flowServer struct {
 	context.T
 	server *server        // ipc.Server that this flow server belongs to
 	disp   ipc.Dispatcher // ipc.Dispatcher that will serve RPCs on this flow
-	dec    *vom.Decoder   // to decode requests and args from the client
-	enc    *vom.Encoder   // to encode responses and results to the client
+	dec    vomDecoder     // to decode requests and args from the client
+	enc    vomEncoder     // to encode responses and results to the client
 	flow   stream.Flow    // underlying flow
 
 	// Fields filled in during the server invocation.
@@ -649,21 +664,33 @@
 
 var _ ipc.Stream = (*flowServer)(nil)
 
-func newFlowServer(flow stream.Flow, server *server) *flowServer {
+func newFlowServer(flow stream.Flow, server *server) (*flowServer, error) {
 	server.Lock()
 	disp := server.disp
 	server.Unlock()
 
-	return &flowServer{
-		T:      server.ctx,
-		server: server,
-		disp:   disp,
-		// TODO(toddw): Support different codecs
-		dec:        vom.NewDecoder(flow),
-		enc:        vom.NewEncoder(flow),
+	fs := &flowServer{
+		T:          server.ctx,
+		server:     server,
+		disp:       disp,
 		flow:       flow,
 		discharges: make(map[string]security.Discharge),
 	}
+	if vom2.IsEnabled() {
+		var err error
+		if fs.dec, err = vom2.NewDecoder(flow); err != nil {
+			flow.Close()
+			return nil, err
+		}
+		if fs.enc, err = vom2.NewBinaryEncoder(flow); err != nil {
+			flow.Close()
+			return nil, err
+		}
+	} else {
+		fs.dec = vom.NewDecoder(flow)
+		fs.enc = vom.NewEncoder(flow)
+	}
+	return fs, nil
 }
 
 // Vom does not encode untyped nils.
@@ -677,7 +704,7 @@
 // - Server methods return 0 or more results
 // - Any values returned by the server that have an interface type are either
 //   non-nil or of type error.
-func result2vom(res interface{}) vom.Value {
+func vomErrorHack(res interface{}) vom.Value {
 	v := vom.ValueOf(res)
 	if !v.IsValid() {
 		// Untyped nils are assumed to be nil-errors.
@@ -693,6 +720,22 @@
 	return v
 }
 
+// TODO(toddw): Remove this function and encodeValueHack after the vom2 transition.
+func vom2ErrorHack(res interface{}) interface{} {
+	if err, ok := res.(error); ok {
+		return &err
+	}
+	return res
+}
+
+// TODO(toddw): Remove this function and vom2ErrorHack after the vom2 transition.
+func (fs *flowServer) encodeValueHack(res interface{}) error {
+	if vom2.IsEnabled() {
+		return fs.enc.Encode(vom2ErrorHack(res))
+	}
+	return fs.enc.(*vom.Encoder).EncodeValue(vomErrorHack(res))
+}
+
 func (fs *flowServer) serve() error {
 	defer fs.flow.Close()
 
@@ -719,7 +762,7 @@
 		return response.Error
 	}
 	for ix, res := range results {
-		if err := fs.enc.EncodeValue(result2vom(res)); err != nil {
+		if err := fs.encodeValueHack(res); err != nil {
 			return verror.BadProtocolf("ipc: result #%d [%T=%v] encoding failed: %v", ix, res, res, err)
 		}
 	}
diff --git a/runtimes/google/ipc/stream/proxy/protocol.vdl.go b/runtimes/google/ipc/stream/proxy/protocol.vdl.go
index c5d943f..fefef65 100644
--- a/runtimes/google/ipc/stream/proxy/protocol.vdl.go
+++ b/runtimes/google/ipc/stream/proxy/protocol.vdl.go
@@ -3,12 +3,22 @@
 
 package proxy
 
+import (
+	// The non-user imports are prefixed with "__" to prevent collisions.
+	__vdl "veyron.io/veyron/veyron2/vdl"
+)
+
 // Request is the message sent by a server to request that the proxy route
 // traffic intended for the server's RoutingID to the network connection
 // between the server and the proxy.
 type Request struct {
 }
 
+func (Request) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/runtimes/google/ipc/stream/proxy.Request"
+}) {
+}
+
 // Response is sent by the proxy to the server after processing Request.
 type Response struct {
 	// Error is a description of why the proxy refused to proxy the server.
@@ -18,3 +28,13 @@
 	// used to communicate with the server through the proxy.
 	Endpoint string
 }
+
+func (Response) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/runtimes/google/ipc/stream/proxy.Response"
+}) {
+}
+
+func init() {
+	__vdl.Register(Request{})
+	__vdl.Register(Response{})
+}
diff --git a/security/agent/agent_test.go b/security/agent/agent_test.go
index d3a0b39..3d9fd8c 100644
--- a/security/agent/agent_test.go
+++ b/security/agent/agent_test.go
@@ -4,7 +4,6 @@
 	"crypto/ecdsa"
 	"crypto/elliptic"
 	"crypto/rand"
-	"errors"
 	"reflect"
 	"testing"
 
@@ -15,6 +14,7 @@
 	"veyron.io/veyron/veyron2/options"
 	"veyron.io/veyron/veyron2/rt"
 	"veyron.io/veyron/veyron2/security"
+	"veyron.io/veyron/veyron2/verror2"
 )
 
 func setupAgent(t *testing.T, p security.Principal) security.Principal {
@@ -39,13 +39,17 @@
 	Method string
 	Args   V
 	Result interface{} // Result returned by the Method call.
-	Error  error       // If Error is not nil will be compared to the last result.
+	Error  verror2.E   // If Error is not nil will be compared to the last result.
 }
 
-var addToRootsErr = errors.New("AddToRoots")
-var storeSetDefaultErr = errors.New("StoreSetDefault")
-var rootsAddErr = errors.New("RootsAdd")
-var rootsRecognizedErr = errors.New("RootsRecognized")
+const pkgPath = "veyron.io/veyron/veyron/security/agent/"
+
+var (
+	addToRootsErr      = verror2.Register(pkgPath+".addToRoots", verror2.NoRetry, "")
+	storeSetDefaultErr = verror2.Register(pkgPath+".storeSetDefault", verror2.NoRetry, "")
+	rootsAddErr        = verror2.Register(pkgPath+".rootsAdd", verror2.NoRetry, "")
+	rootsRecognizedErr = verror2.Register(pkgPath+".rootsRecognized", verror2.NoRetry, "")
+)
 
 func TestAgent(t *testing.T) {
 	var (
@@ -56,10 +60,12 @@
 	tests := []testInfo{
 		{"BlessSelf", V{"self"}, newBlessing(t, "blessing"), nil},
 		{"Bless", V{newPrincipal(t).PublicKey(), newBlessing(t, "root"), "extension", security.UnconstrainedUse()}, newBlessing(t, "root/extension"), nil},
+		// TODO(toddw): This change is necessary for vom2:
+		//{"Sign", V{make([]byte, 10)}, security.Signature{Purpose: []byte{}, R: []byte{1}, S: []byte{1}}, nil},
 		{"Sign", V{make([]byte, 10)}, security.Signature{R: []byte{1}, S: []byte{1}}, nil},
 		{"MintDischarge", V{thirdPartyCaveat, security.UnconstrainedUse()}, discharge, nil},
 		{"PublicKey", V{}, mockP.PublicKey(), nil},
-		{"AddToRoots", V{newBlessing(t, "blessing")}, nil, addToRootsErr},
+		{"AddToRoots", V{newBlessing(t, "blessing")}, nil, verror2.Make(addToRootsErr, nil)},
 	}
 	for _, test := range tests {
 		mockP.NextResult = test.Result
@@ -71,7 +77,7 @@
 	storeTests := []testInfo{
 		{"Set", V{newBlessing(t, "blessing"), security.BlessingPattern("test")}, newBlessing(t, "root/extension"), nil},
 		{"ForPeer", V{"test", "oink"}, newBlessing(t, "for/peer"), nil},
-		{"SetDefault", V{newBlessing(t, "blessing")}, nil, storeSetDefaultErr},
+		{"SetDefault", V{newBlessing(t, "blessing")}, nil, verror2.Make(storeSetDefaultErr, nil)},
 		{"Default", V{}, newBlessing(t, "root/extension"), nil},
 		{"PublicKey", V{}, mockP.PublicKey(), nil},
 		{"DebugString", V{}, "StoreString", nil},
@@ -84,8 +90,8 @@
 
 	roots := agent.Roots()
 	rootTests := []testInfo{
-		{"Add", V{newPrincipal(t).PublicKey(), security.BlessingPattern("test")}, nil, rootsAddErr},
-		{"Recognized", V{newPrincipal(t).PublicKey(), "blessing"}, nil, rootsRecognizedErr},
+		{"Add", V{newPrincipal(t).PublicKey(), security.BlessingPattern("test")}, nil, verror2.Make(rootsAddErr, nil)},
+		{"Recognized", V{newPrincipal(t).PublicKey(), "blessing"}, nil, verror2.Make(rootsRecognizedErr, nil)},
 		{"DebugString", V{}, "RootsString", nil},
 	}
 	for _, test := range rootTests {
@@ -103,7 +109,7 @@
 	}
 	// We only set the error value when error is the only output to ensure the real function gets called.
 	if test.Error != nil {
-		if got := results[len(results)-1]; got == nil || got.(error).Error() != test.Error.Error() {
+		if got := results[len(results)-1]; got == nil || !verror2.Is(got.(error), test.Error.ErrorID()) {
 			t.Errorf("p.%v(%#v) returned an incorrect error: %v, expected %v", test.Method, test.Args, got, test.Error)
 		}
 		if len(results) == 1 {
@@ -111,7 +117,7 @@
 		}
 	}
 	if got := results[0]; !reflect.DeepEqual(got, test.Result) {
-		t.Errorf("p.%v(%#v) returned %v(%T) want %v(%T)", test.Method, test.Args, got, got, test.Result, test.Result)
+		t.Errorf("p.%v(%#v) returned %#v want %#v", test.Method, test.Args, got, test.Result)
 	}
 }
 
diff --git a/security/serialization/verifying_reader.go b/security/serialization/verifying_reader.go
index 2a240b6..e8f1f44 100644
--- a/security/serialization/verifying_reader.go
+++ b/security/serialization/verifying_reader.go
@@ -9,6 +9,7 @@
 	"io"
 
 	"veyron.io/veyron/veyron2/security"
+	"veyron.io/veyron/veyron2/vdl/vdlutil"
 	"veyron.io/veyron/veyron2/vom"
 )
 
@@ -119,5 +120,5 @@
 }
 
 func init() {
-	vom.Register([sha256.Size]byte{})
+	vdlutil.Register([sha256.Size]byte{})
 }
diff --git a/security/util_test.go b/security/util_test.go
index 6d07a22..194443f 100644
--- a/security/util_test.go
+++ b/security/util_test.go
@@ -9,7 +9,7 @@
 	"testing"
 
 	"veyron.io/veyron/veyron2/security"
-	"veyron.io/veyron/veyron2/vom"
+	"veyron.io/veyron/veyron2/vdl/vdlutil"
 )
 
 func TestLoadSavePEMKey(t *testing.T) {
@@ -121,6 +121,6 @@
 }
 
 func init() {
-	vom.Register(&fpCaveat{})
-	vom.Register(&tpCaveat{})
+	vdlutil.Register(&fpCaveat{})
+	vdlutil.Register(&tpCaveat{})
 }
diff --git a/services/identity/revocation/revocation_manager.go b/services/identity/revocation/revocation_manager.go
index b4b2178..4a45a9a 100644
--- a/services/identity/revocation/revocation_manager.go
+++ b/services/identity/revocation/revocation_manager.go
@@ -9,7 +9,7 @@
 	"time"
 
 	"veyron.io/veyron/veyron2/security"
-	"veyron.io/veyron/veyron2/vom"
+	"veyron.io/veyron/veyron2/vdl/vdlutil"
 )
 
 // RevocationManager persists information for revocation caveats to provided discharges and allow for future revocations.
@@ -89,5 +89,5 @@
 }
 
 func init() {
-	vom.Register(revocationCaveat{})
+	vdlutil.Register(revocationCaveat{})
 }
diff --git a/services/mgmt/application/impl/impl_test.go b/services/mgmt/application/impl/impl_test.go
index 50e9ce2..9b4395c 100644
--- a/services/mgmt/application/impl/impl_test.go
+++ b/services/mgmt/application/impl/impl_test.go
@@ -9,6 +9,7 @@
 	"veyron.io/veyron/veyron2/naming"
 	"veyron.io/veyron/veyron2/rt"
 	"veyron.io/veyron/veyron2/services/mgmt/application"
+	"veyron.io/veyron/veyron2/verror2"
 
 	"veyron.io/veyron/veyron/lib/testutil"
 	"veyron.io/veyron/veyron/profiles"
@@ -69,7 +70,7 @@
 	if err := stubV2.Put(ctx, []string{"base"}, envelopeV2); err != nil {
 		t.Fatalf("Put() failed: %v", err)
 	}
-	if err := stub.Put(ctx, []string{"base", "media"}, envelopeV1); err == nil || err.Error() != errInvalidSuffix.Error() {
+	if err := stub.Put(ctx, []string{"base", "media"}, envelopeV1); err == nil || !verror2.Is(err, errInvalidSuffix.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errInvalidSuffix, err)
 	}
 
@@ -88,13 +89,13 @@
 	if !reflect.DeepEqual(envelopeV1, output) {
 		t.Fatalf("Unexpected output: expected %v, got %v", envelopeV1, output)
 	}
-	if _, err := stubV2.Match(ctx, []string{"media"}); err == nil || err.Error() != errNotFound.Error() {
+	if _, err := stubV2.Match(ctx, []string{"media"}); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
-	if _, err := stubV2.Match(ctx, []string{}); err == nil || err.Error() != errNotFound.Error() {
+	if _, err := stubV2.Match(ctx, []string{}); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
-	if _, err := stub.Match(ctx, []string{"media"}); err == nil || err.Error() != errInvalidSuffix.Error() {
+	if _, err := stub.Match(ctx, []string{"media"}); err == nil || !verror2.Is(err, errInvalidSuffix.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errInvalidSuffix, err)
 	}
 
@@ -121,13 +122,13 @@
 	if output, err = stubV1.Match(ctx, []string{"media"}); err != nil {
 		t.Fatalf("Match() failed: %v", err)
 	}
-	if err := stubV1.Remove(ctx, "base"); err == nil || err.Error() != errNotFound.Error() {
+	if err := stubV1.Remove(ctx, "base"); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
 	if err := stub.Remove(ctx, "base"); err != nil {
 		t.Fatalf("Remove() failed: %v", err)
 	}
-	if err := stubV2.Remove(ctx, "media"); err == nil || err.Error() != errNotFound.Error() {
+	if err := stubV2.Remove(ctx, "media"); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
 	if err := stubV1.Remove(ctx, "media"); err != nil {
@@ -136,13 +137,13 @@
 
 	// Finally, use Match() to test that Remove really removed the
 	// application envelopes.
-	if _, err := stubV1.Match(ctx, []string{"base"}); err == nil || err.Error() != errNotFound.Error() {
+	if _, err := stubV1.Match(ctx, []string{"base"}); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
-	if _, err := stubV1.Match(ctx, []string{"media"}); err == nil || err.Error() != errNotFound.Error() {
+	if _, err := stubV1.Match(ctx, []string{"media"}); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
-	if _, err := stubV2.Match(ctx, []string{"base"}); err == nil || err.Error() != errNotFound.Error() {
+	if _, err := stubV2.Match(ctx, []string{"base"}); err == nil || !verror2.Is(err, errNotFound.ID) {
 		t.Fatalf("Unexpected error: expected %v, got %v", errNotFound, err)
 	}
 
diff --git a/services/mgmt/application/impl/service.go b/services/mgmt/application/impl/service.go
index 76c930b..a42dcab 100644
--- a/services/mgmt/application/impl/service.go
+++ b/services/mgmt/application/impl/service.go
@@ -1,13 +1,13 @@
 package impl
 
 import (
-	"errors"
 	"strings"
 
 	"veyron.io/veyron/veyron/services/mgmt/lib/fs"
 	"veyron.io/veyron/veyron2/ipc"
 	"veyron.io/veyron/veyron2/naming"
 	"veyron.io/veyron/veyron2/services/mgmt/application"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -24,10 +24,12 @@
 	suffix string
 }
 
+const pkgPath = "veyron.io/veyron/veyron/services/mgmt/application/impl/"
+
 var (
-	errInvalidSuffix   = errors.New("invalid suffix")
-	errOperationFailed = errors.New("operation failed")
-	errNotFound        = errors.New("not found")
+	errInvalidSuffix   = verror2.Register(pkgPath+".invalidSuffix", verror2.NoRetry, "")
+	errOperationFailed = verror2.Register(pkgPath+".operationFailed", verror2.NoRetry, "")
+	errNotFound        = verror2.Register(pkgPath+".notFound", verror2.NoRetry, "")
 )
 
 // NewApplicationService returns a new Application service implementation.
@@ -35,7 +37,7 @@
 	return &appRepoService{store: store, storeRoot: storeRoot, suffix: suffix}
 }
 
-func parse(suffix string) (string, string, error) {
+func parse(context ipc.ServerContext, suffix string) (string, string, error) {
 	tokens := strings.Split(suffix, "/")
 	switch len(tokens) {
 	case 2:
@@ -43,19 +45,19 @@
 	case 1:
 		return tokens[0], "", nil
 	default:
-		return "", "", errInvalidSuffix
+		return "", "", verror2.Make(errInvalidSuffix, context)
 	}
 }
 
 func (i *appRepoService) Match(context ipc.ServerContext, profiles []string) (application.Envelope, error) {
 	vlog.VI(0).Infof("%v.Match(%v)", i.suffix, profiles)
 	empty := application.Envelope{}
-	name, version, err := parse(i.suffix)
+	name, version, err := parse(context, i.suffix)
 	if err != nil {
 		return empty, err
 	}
 	if version == "" {
-		return empty, errInvalidSuffix
+		return empty, verror2.Make(errInvalidSuffix, context)
 	}
 
 	i.store.Lock()
@@ -73,17 +75,17 @@
 		}
 		return envelope, nil
 	}
-	return empty, errNotFound
+	return empty, verror2.Make(errNotFound, context)
 }
 
 func (i *appRepoService) Put(context ipc.ServerContext, profiles []string, envelope application.Envelope) error {
 	vlog.VI(0).Infof("%v.Put(%v, %v)", i.suffix, profiles, envelope)
-	name, version, err := parse(i.suffix)
+	name, version, err := parse(context, i.suffix)
 	if err != nil {
 		return err
 	}
 	if version == "" {
-		return errInvalidSuffix
+		return verror2.Make(errInvalidSuffix, context)
 	}
 	i.store.Lock()
 	defer i.store.Unlock()
@@ -99,18 +101,18 @@
 		object := i.store.BindObject(path)
 		_, err := object.Put(context, envelope)
 		if err != nil {
-			return errOperationFailed
+			return verror2.Make(errOperationFailed, context)
 		}
 	}
 	if err := i.store.BindTransaction(tname).Commit(context); err != nil {
-		return errOperationFailed
+		return verror2.Make(errOperationFailed, context)
 	}
 	return nil
 }
 
 func (i *appRepoService) Remove(context ipc.ServerContext, profile string) error {
 	vlog.VI(0).Infof("%v.Remove(%v)", i.suffix, profile)
-	name, version, err := parse(i.suffix)
+	name, version, err := parse(context, i.suffix)
 	if err != nil {
 		return err
 	}
@@ -128,16 +130,16 @@
 	object := i.store.BindObject(path)
 	found, err := object.Exists(context)
 	if err != nil {
-		return errOperationFailed
+		return verror2.Make(errOperationFailed, context)
 	}
 	if !found {
-		return errNotFound
+		return verror2.Make(errNotFound, context)
 	}
 	if err := object.Remove(context); err != nil {
-		return errOperationFailed
+		return verror2.Make(errOperationFailed, context)
 	}
 	if err := i.store.BindTransaction(tname).Commit(context); err != nil {
-		return errOperationFailed
+		return verror2.Make(errOperationFailed, context)
 	}
 	return nil
 }
@@ -207,9 +209,9 @@
 				return nil, nil
 			}
 		}
-		return nil, errNotFound
+		return nil, verror2.Make(errNotFound, nil)
 	default:
-		return nil, errNotFound
+		return nil, verror2.Make(errNotFound, nil)
 	}
 
 	ch := make(chan string, len(results))
diff --git a/services/mgmt/node/impl/app_service.go b/services/mgmt/node/impl/app_service.go
index dff4976..b5ab1ab 100644
--- a/services/mgmt/node/impl/app_service.go
+++ b/services/mgmt/node/impl/app_service.go
@@ -136,7 +136,7 @@
 	"veyron.io/veyron/veyron2/services/mgmt/appcycle"
 	"veyron.io/veyron/veyron2/services/mgmt/application"
 	"veyron.io/veyron/veyron2/services/security/access"
-	"veyron.io/veyron/veyron2/verror"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 
 	vexec "veyron.io/veyron/veyron/lib/exec"
@@ -161,12 +161,12 @@
 	jsonInfo, err := json.Marshal(info)
 	if err != nil {
 		vlog.Errorf("Marshal(%v) failed: %v", info, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	infoPath := filepath.Join(dir, "info")
 	if err := ioutil.WriteFile(infoPath, jsonInfo, 0600); err != nil {
 		vlog.Errorf("WriteFile(%v) failed: %v", infoPath, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -176,10 +176,10 @@
 	info := new(instanceInfo)
 	if infoBytes, err := ioutil.ReadFile(infoPath); err != nil {
 		vlog.Errorf("ReadFile(%v) failed: %v", infoPath, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	} else if err := json.Unmarshal(infoBytes, info); err != nil {
 		vlog.Errorf("Unmarshal(%v) failed: %v", infoBytes, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	}
 	return info, nil
 }
@@ -216,12 +216,12 @@
 	jsonEnvelope, err := json.Marshal(envelope)
 	if err != nil {
 		vlog.Errorf("Marshal(%v) failed: %v", envelope, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	path := filepath.Join(dir, "envelope")
 	if err := ioutil.WriteFile(path, jsonEnvelope, 0600); err != nil {
 		vlog.Errorf("WriteFile(%v) failed: %v", path, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -231,10 +231,10 @@
 	envelope := new(application.Envelope)
 	if envelopeBytes, err := ioutil.ReadFile(path); err != nil {
 		vlog.Errorf("ReadFile(%v) failed: %v", path, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	} else if err := json.Unmarshal(envelopeBytes, envelope); err != nil {
 		vlog.Errorf("Unmarshal(%v) failed: %v", envelopeBytes, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	}
 	return envelope, nil
 }
@@ -243,7 +243,7 @@
 	path := filepath.Join(dir, "origin")
 	if err := ioutil.WriteFile(path, []byte(originVON), 0600); err != nil {
 		vlog.Errorf("WriteFile(%v) failed: %v", path, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -252,7 +252,7 @@
 	path := filepath.Join(dir, "origin")
 	if originBytes, err := ioutil.ReadFile(path); err != nil {
 		vlog.Errorf("ReadFile(%v) failed: %v", path, err)
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, nil)
 	} else {
 		return string(originBytes), nil
 	}
@@ -318,7 +318,7 @@
 	if envelope.Title == application.NodeManagerTitle {
 		// Disallow node manager apps from being installed like a
 		// regular app.
-		return nil, errInvalidOperation
+		return nil, verror2.Make(ErrInvalidOperation, ctx)
 	}
 	return envelope, nil
 }
@@ -327,11 +327,11 @@
 func newVersion(installationDir string, envelope *application.Envelope, oldVersionDir string) (string, error) {
 	versionDir := filepath.Join(installationDir, generateVersionDirName())
 	if err := mkdir(versionDir); err != nil {
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, nil)
 	}
 	pkgDir := filepath.Join(versionDir, "pkg")
 	if err := mkdir(pkgDir); err != nil {
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, nil)
 	}
 	// TODO(caprita): Share binaries if already existing locally.
 	if err := downloadBinary(versionDir, "bin", envelope.Binary); err != nil {
@@ -340,12 +340,12 @@
 	for localPkg, pkgName := range envelope.Packages {
 		if localPkg == "" || localPkg[0] == '.' || strings.Contains(localPkg, string(filepath.Separator)) {
 			vlog.Infof("invalid local package name: %q", localPkg)
-			return versionDir, errOperationFailed
+			return versionDir, verror2.Make(ErrOperationFailed, nil)
 		}
 		path := filepath.Join(pkgDir, localPkg)
 		if err := libbinary.DownloadToFile(rt.R().NewContext(), pkgName, path); err != nil {
 			vlog.Infof("DownloadToFile(%q, %q) failed: %v", pkgName, path, err)
-			return versionDir, errOperationFailed
+			return versionDir, verror2.Make(ErrOperationFailed, nil)
 		}
 	}
 	if err := saveEnvelope(versionDir, envelope); err != nil {
@@ -355,7 +355,7 @@
 		previousLink := filepath.Join(versionDir, "previous")
 		if err := os.Symlink(oldVersionDir, previousLink); err != nil {
 			vlog.Errorf("Symlink(%v, %v) failed: %v", oldVersionDir, previousLink, err)
-			return versionDir, errOperationFailed
+			return versionDir, verror2.Make(ErrOperationFailed, nil)
 		}
 	}
 	// updateLink should be the last thing we do, after we've ensured the
@@ -380,7 +380,7 @@
 
 func (i *appService) Install(call ipc.ServerContext, applicationVON string) (string, error) {
 	if len(i.suffix) > 0 {
-		return "", errInvalidSuffix
+		return "", verror2.Make(ErrInvalidSuffix, call)
 	}
 	ctx, cancel := rt.R().NewContext().WithTimeout(ipcContextTimeout)
 	defer cancel()
@@ -433,23 +433,23 @@
 	file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE, perm)
 	if err != nil {
 		vlog.Errorf("OpenFile(%v) failed: %v", path, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	}
 	return file, nil
 }
 
 func installationDirCore(components []string, root string) (string, error) {
 	if nComponents := len(components); nComponents != 2 {
-		return "", errInvalidSuffix
+		return "", verror2.Make(ErrInvalidSuffix, nil)
 	}
 	app, installation := components[0], components[1]
 	installationDir := filepath.Join(root, applicationDirName(app), installationDirName(installation))
 	if _, err := os.Stat(installationDir); err != nil {
 		if os.IsNotExist(err) {
-			return "", errNotExist
+			return "", verror2.Make(ErrObjectNoExist, nil)
 		}
 		vlog.Errorf("Stat(%v) failed: %v", installationDir, err)
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, nil)
 	}
 	return installationDir, nil
 }
@@ -465,13 +465,13 @@
 		client, err := rt.R().NewClient(options.VCSecurityNone)
 		if err != nil {
 			vlog.Errorf("NewClient() failed: %v", err)
-			return errOperationFailed
+			return verror2.Make(ErrOperationFailed, nil)
 		}
 		defer client.Close()
 		// TODO(caprita): release the socket created by NewAgentPrincipal.
 		if p, err = agent.NewAgentPrincipal(client, int(conn.Fd()), rt.R().NewContext()); err != nil {
 			vlog.Errorf("NewAgentPrincipal() failed: %v", err)
-			return errOperationFailed
+			return verror2.Make(ErrOperationFailed, nil)
 		}
 		info.SecurityAgentHandle = handle
 	} else {
@@ -481,7 +481,7 @@
 		var err error
 		if p, err = vsecurity.CreatePersistentPrincipal(credentialsDir, nil); err != nil {
 			vlog.Errorf("CreatePersistentPrincipal(%v, nil) failed: %v", credentialsDir, err)
-			return errOperationFailed
+			return verror2.Make(ErrOperationFailed, nil)
 		}
 	}
 	// Read the app installation version's envelope to obtain the app title.
@@ -498,27 +498,27 @@
 	// with the app title.
 	grantedBlessings := call.Blessings()
 	if grantedBlessings == nil {
-		return errInvalidBlessing
+		return verror2.Make(ErrInvalidBlessing, nil)
 	}
 	// TODO(caprita): Revisit UnconstrainedUse.
 	appBlessings, err := nmPrincipal.Bless(p.PublicKey(), grantedBlessings, envelope.Title, security.UnconstrainedUse())
 	if err != nil {
 		vlog.Errorf("Bless() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	// The blessings we extended from the blessings that the Start-er
 	// granted are the default blessings for the app.
 	if err := p.BlessingStore().SetDefault(appBlessings); err != nil {
 		vlog.Errorf("BlessingStore.SetDefault() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if _, err := p.BlessingStore().Set(appBlessings, security.AllPrincipals); err != nil {
 		vlog.Errorf("BlessingStore.Set() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err := p.AddToRoots(appBlessings); err != nil {
 		vlog.Errorf("AddToRoots() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	// In addition, we give the app separate blessings for the purpose of
 	// communicating with the node manager.
@@ -541,7 +541,7 @@
 	for _, n := range names {
 		if _, err := p.BlessingStore().Set(nmBlessings, security.BlessingPattern(n)); err != nil {
 			vlog.Errorf("BlessingStore.Set() failed: %v", err)
-			return errOperationFailed
+			return verror2.Make(ErrOperationFailed, nil)
 		}
 	}
 	// We also want to override the app cycle manager's server blessing in
@@ -551,16 +551,16 @@
 	randomPattern, err := generateRandomString()
 	if err != nil {
 		vlog.Errorf("generateRandomString() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if _, err := p.BlessingStore().Set(nmBlessings, security.BlessingPattern(randomPattern)); err != nil {
 		vlog.Errorf("BlessingStore.Set() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	info.NodeManagerPeerPattern = randomPattern
 	if err := p.AddToRoots(nmBlessings); err != nil {
 		vlog.Errorf("AddToRoots() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -617,27 +617,27 @@
 		return "", "", err
 	}
 	if !installationStateIs(installationDir, active) {
-		return "", "", errInvalidOperation
+		return "", "", verror2.Make(ErrInvalidOperation, call)
 	}
 	instanceID := generateID()
 	instanceDir := filepath.Join(installationDir, "instances", instanceDirName(instanceID))
 	if mkdir(instanceDir) != nil {
-		return "", instanceID, errOperationFailed
+		return "", instanceID, verror2.Make(ErrOperationFailed, call)
 	}
 	currLink := filepath.Join(installationDir, "current")
 	versionDir, err := filepath.EvalSymlinks(currLink)
 	if err != nil {
 		vlog.Errorf("EvalSymlinks(%v) failed: %v", currLink, err)
-		return instanceDir, instanceID, errOperationFailed
+		return instanceDir, instanceID, verror2.Make(ErrOperationFailed, call)
 	}
 	versionLink := filepath.Join(instanceDir, "version")
 	if err := os.Symlink(versionDir, versionLink); err != nil {
 		vlog.Errorf("Symlink(%v, %v) failed: %v", versionDir, versionLink, err)
-		return instanceDir, instanceID, errOperationFailed
+		return instanceDir, instanceID, verror2.Make(ErrOperationFailed, call)
 	}
 	if err := installPackages(versionDir, instanceDir); err != nil {
 		vlog.Errorf("installPackages(%v, %v) failed: %v", versionDir, instanceDir, err)
-		return instanceDir, instanceID, errOperationFailed
+		return instanceDir, instanceID, verror2.Make(ErrOperationFailed, call)
 	}
 	instanceInfo := new(instanceInfo)
 	if err := setupPrincipal(instanceDir, versionDir, call, i.securityAgent, instanceInfo); err != nil {
@@ -671,11 +671,12 @@
 // and is probably not a good fit in other contexts. Revisit the design
 // as appropriate. This function also internalizes a decision as to when
 // it is possible to start an application that needs to be made explicit.
-func systemAccountForHelper(helperPath string, identityNames []string, uat BlessingSystemAssociationStore) (systemName string, err error) {
+func systemAccountForHelper(ctx ipc.ServerContext, helperPath string, uat BlessingSystemAssociationStore) (systemName string, err error) {
+	identityNames := ctx.RemoteBlessings().ForContext(ctx)
 	helperStat, err := os.Stat(helperPath)
 	if err != nil {
 		vlog.Errorf("Stat(%v) failed: %v. helper is required.", helperPath, err)
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, ctx)
 	}
 	haveHelper := isSetuid(helperStat)
 	systemName, present := uat.SystemAccountForBlessings(identityNames)
@@ -688,7 +689,7 @@
 		// Therefore, the node manager must never run an app as itself to
 		// prevent an app trivially granting itself root permissions.
 		// There must be an associated uname for the account in this case.
-		return "", verror.NoAccessf("use of setuid helper requires an associated uname.")
+		return "", verror2.Make(verror2.NoAccess, ctx, "use of setuid helper requires an associated uname.")
 	case !haveHelper:
 		// When the helper is not setuid, the helper can't change the
 		// app's uid so just run the app as the node manager's uname
@@ -697,11 +698,11 @@
 		user, err := user.Current()
 		if err != nil {
 			vlog.Errorf("user.Current() failed: %v", err)
-			return "", errOperationFailed
+			return "", verror2.Make(ErrOperationFailed, ctx)
 		}
 		return user.Username, nil
 	}
-	return "", errOperationFailed
+	return "", verror2.Make(ErrOperationFailed, ctx)
 }
 
 func genCmd(instanceDir, helperPath, systemName string) (*exec.Cmd, error) {
@@ -709,7 +710,7 @@
 	versionDir, err := filepath.EvalSymlinks(versionLink)
 	if err != nil {
 		vlog.Errorf("EvalSymlinks(%v) failed: %v", versionLink, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	}
 	envelope, err := loadEnvelope(versionDir)
 	if err != nil {
@@ -718,7 +719,7 @@
 	binPath := filepath.Join(versionDir, "bin")
 	if _, err := os.Stat(binPath); err != nil {
 		vlog.Errorf("Stat(%v) failed: %v", binPath, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, nil)
 	}
 
 	cmd := exec.Command(helperPath)
@@ -818,7 +819,7 @@
 			agentCleaner()
 		}
 		vlog.Errorf("Start() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if agentCleaner != nil {
 		agentCleaner()
@@ -827,11 +828,11 @@
 	// Wait for the child process to start.
 	if err := handle.WaitForReady(childReadyTimeout); err != nil {
 		vlog.Errorf("WaitForReady(%v) failed: %v", childReadyTimeout, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	childName, err := listener.waitForValue(childReadyTimeout)
 	if err != nil {
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	info.AppCycleMgrName, info.Pid = childName, handle.Pid()
 	if err := saveInstanceInfo(instanceDir, info); err != nil {
@@ -868,7 +869,7 @@
 		return nil, err
 	}
 
-	systemName, err := systemAccountForHelper(helper, call.RemoteBlessings().ForContext(call), i.uat)
+	systemName, err := systemAccountForHelper(call, helper, i.uat)
 	if err != nil {
 		cleanupDir(instanceDir, helper)
 		return nil, err
@@ -893,7 +894,7 @@
 // referred to by the given suffix relative to the given root directory.
 func instanceDir(root string, suffix []string) (string, error) {
 	if nComponents := len(suffix); nComponents != 3 {
-		return "", errInvalidSuffix
+		return "", verror2.Make(ErrInvalidSuffix, nil)
 	}
 	app, installation, instance := suffix[0], suffix[1], suffix[2]
 	instancesDir := filepath.Join(root, applicationDirName(app), installationDirName(installation), "instances")
@@ -914,7 +915,7 @@
 		return err
 	}
 
-	systemName, err := systemAccountForHelper(i.config.Helper, call.RemoteBlessings().ForContext(call), i.uat)
+	systemName, err := systemAccountForHelper(call, i.config.Helper, i.uat)
 	if err != nil {
 		return err
 	}
@@ -925,7 +926,7 @@
 	}
 
 	if startSystemName != systemName {
-		return verror.NoAccessf("Not allowed to resume an application under a different system name.")
+		return verror2.Make(verror2.NoAccess, call, "Not allowed to resume an application under a different system name.")
 	}
 	return i.run(instanceDir, systemName)
 }
@@ -937,7 +938,7 @@
 	stream, err := appStub.Stop(ctx)
 	if err != nil {
 		vlog.Errorf("%v.Stop() failed: %v", appVON, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	rstream := stream.RecvStream()
 	for rstream.Advance() {
@@ -945,11 +946,11 @@
 	}
 	if err := rstream.Err(); err != nil {
 		vlog.Errorf("Advance() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err := stream.Finish(); err != nil {
 		vlog.Errorf("Finish() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -969,7 +970,7 @@
 	if err != nil {
 		return err
 	}
-	if err := transitionInstance(instanceDir, suspended, stopped); err == errOperationFailed || err == nil {
+	if err := transitionInstance(instanceDir, suspended, stopped); verror2.Is(err, ErrOperationFailed.ID) || err == nil {
 		return err
 	}
 	if err := transitionInstance(instanceDir, started, stopping); err != nil {
@@ -1005,13 +1006,13 @@
 	return transitionInstallation(installationDir, active, uninstalled)
 }
 
-func (i *appService) Update(ipc.ServerContext) error {
+func (i *appService) Update(call ipc.ServerContext) error {
 	installationDir, err := i.installationDir()
 	if err != nil {
 		return err
 	}
 	if !installationStateIs(installationDir, active) {
-		return errInvalidOperation
+		return verror2.Make(ErrInvalidOperation, call)
 	}
 	originVON, err := loadOrigin(installationDir)
 	if err != nil {
@@ -1027,7 +1028,7 @@
 	oldVersionDir, err := filepath.EvalSymlinks(currLink)
 	if err != nil {
 		vlog.Errorf("EvalSymlinks(%v) failed: %v", currLink, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, call)
 	}
 	// NOTE(caprita): A race can occur between two competing updates, where
 	// both use the old version as their baseline.  This can result in both
@@ -1042,10 +1043,10 @@
 		return err
 	}
 	if oldEnvelope.Title != newEnvelope.Title {
-		return errIncompatibleUpdate
+		return verror2.Make(ErrAppTitleMismatch, call)
 	}
 	if reflect.DeepEqual(oldEnvelope, newEnvelope) {
-		return errUpdateNoOp
+		return verror2.Make(ErrUpdateNoOp, call)
 	}
 	versionDir, err := newVersion(installationDir, newEnvelope, oldVersionDir)
 	if err != nil {
@@ -1060,13 +1061,13 @@
 	return nil
 }
 
-func (i *appService) Revert(ipc.ServerContext) error {
+func (i *appService) Revert(ctx ipc.ServerContext) error {
 	installationDir, err := i.installationDir()
 	if err != nil {
 		return err
 	}
 	if !installationStateIs(installationDir, active) {
-		return errInvalidOperation
+		return verror2.Make(ErrInvalidOperation, ctx)
 	}
 	// NOTE(caprita): A race can occur between an update and a revert, where
 	// both use the same current version as their starting point.  This will
@@ -1077,21 +1078,21 @@
 	currVersionDir, err := filepath.EvalSymlinks(currLink)
 	if err != nil {
 		vlog.Errorf("EvalSymlinks(%v) failed: %v", currLink, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	previousLink := filepath.Join(currVersionDir, "previous")
 	if _, err := os.Lstat(previousLink); err != nil {
 		if os.IsNotExist(err) {
 			// No 'previous' link -- must be the first version.
-			return errUpdateNoOp
+			return verror2.Make(ErrUpdateNoOp, ctx)
 		}
 		vlog.Errorf("Lstat(%v) failed: %v", previousLink, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	prevVersionDir, err := filepath.EvalSymlinks(previousLink)
 	if err != nil {
 		vlog.Errorf("EvalSymlinks(%v) failed: %v", previousLink, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	return updateLink(prevVersionDir, currLink)
 }
@@ -1210,11 +1211,11 @@
 		}
 		i.scanInstance(tree, i.suffix[0], dir)
 	default:
-		return nil, errNotExist
+		return nil, verror2.Make(ErrObjectNoExist, nil)
 	}
 	n := tree.find(i.suffix, false)
 	if n == nil {
-		return nil, errInvalidSuffix
+		return nil, verror2.Make(ErrInvalidSuffix, nil)
 	}
 	ch := make(chan string, 100)
 	go func() {
@@ -1243,7 +1244,7 @@
 		}
 		return p, nil
 	}
-	return "", errInvalidSuffix
+	return "", verror2.Make(ErrInvalidSuffix, nil)
 }
 
 // TODO(rjkroege): Consider maintaining an in-memory ACL cache.
diff --git a/services/mgmt/node/impl/app_state.go b/services/mgmt/node/impl/app_state.go
index 9fbc1c2..63071ca 100644
--- a/services/mgmt/node/impl/app_state.go
+++ b/services/mgmt/node/impl/app_state.go
@@ -6,6 +6,7 @@
 	"os"
 	"path/filepath"
 
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -98,10 +99,10 @@
 	targetState := filepath.Join(dir, target.String())
 	if err := os.Rename(initialState, targetState); err != nil {
 		if os.IsNotExist(err) {
-			return errInvalidOperation
+			return verror2.Make(ErrInvalidOperation, nil)
 		}
 		vlog.Errorf("Rename(%v, %v) failed: %v", initialState, targetState, err) // Something went really wrong.
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -110,7 +111,7 @@
 	initialStatus := filepath.Join(dir, initial.String())
 	if err := ioutil.WriteFile(initialStatus, []byte("status"), 0600); err != nil {
 		vlog.Errorf("WriteFile(%v) failed: %v", initialStatus, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
diff --git a/services/mgmt/node/impl/association_instance.go b/services/mgmt/node/impl/association_instance.go
index 02ae3a7..32dd993 100644
--- a/services/mgmt/node/impl/association_instance.go
+++ b/services/mgmt/node/impl/association_instance.go
@@ -7,6 +7,7 @@
 	"io/ioutil"
 	"path/filepath"
 
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -14,7 +15,7 @@
 	snp := filepath.Join(dir, "systemname")
 	if err := ioutil.WriteFile(snp, []byte(systemName), 0600); err != nil {
 		vlog.Errorf("WriteFile(%v, %v) failed: %v", snp, systemName, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -24,7 +25,7 @@
 	name, err := ioutil.ReadFile(snp)
 	if err != nil {
 		vlog.Errorf("ReadFile(%v) failed: %v", snp, err)
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, nil)
 	}
 	return string(name), nil
 }
diff --git a/services/mgmt/node/impl/association_state.go b/services/mgmt/node/impl/association_state.go
index 8fe738f..1e9a285 100644
--- a/services/mgmt/node/impl/association_state.go
+++ b/services/mgmt/node/impl/association_state.go
@@ -1,13 +1,13 @@
 package impl
 
 import (
+	"encoding/json"
 	"os"
 	"path/filepath"
-	"veyron.io/veyron/veyron2/services/mgmt/node"
-	"veyron.io/veyron/veyron2/verror"
-
-	"encoding/json"
 	"sync"
+
+	"veyron.io/veyron/veyron2/services/mgmt/node"
+	"veyron.io/veyron/veyron2/verror2"
 )
 
 // BlessingSystemAssociationStore manages a persisted association between
@@ -65,7 +65,7 @@
 func (u *association) serialize() (err error) {
 	f, err := os.OpenFile(u.filename, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
 	if err != nil {
-		return verror.NoExistf("Could not open association file for writing %s: %v", u.filename, err)
+		return verror2.Make(verror2.NoExist, nil, "Could not open association file for writing", u.filename, err)
 	}
 	defer func() {
 		if closerr := f.Close(); closerr != nil {
@@ -100,13 +100,13 @@
 func NewBlessingSystemAssociationStore(root string) (BlessingSystemAssociationStore, error) {
 	nddir := filepath.Join(root, "node-manager", "node-data")
 	if err := os.MkdirAll(nddir, os.FileMode(0700)); err != nil {
-		return nil, verror.NoExistf("Could not create node-data directory %s: %v\n", nddir, err)
+		return nil, verror2.Make(verror2.NoExist, nil, "Could not create node-data directory", nddir, err)
 	}
 	msf := filepath.Join(nddir, "associated.accounts")
 
 	f, err := os.Open(msf)
 	if err != nil && os.IsExist(err) {
-		return nil, verror.NoExistf("Could not open association file %s: %v\n", msf, err)
+		return nil, verror2.Make(verror2.NoExist, nil, "Could not open association file", msf, err)
 
 	}
 	defer f.Close()
@@ -117,7 +117,7 @@
 		dec := json.NewDecoder(f)
 		err := dec.Decode(&a.data)
 		if err != nil {
-			return nil, verror.NoExistf("Could not read association file %s: %v\n", msf, err)
+			return nil, verror2.Make(verror2.NoExist, nil, "Could not read association file", msf, err)
 		}
 	}
 	return BlessingSystemAssociationStore(a), nil
diff --git a/services/mgmt/node/impl/config_service.go b/services/mgmt/node/impl/config_service.go
index 609e1c6..b7c504d 100644
--- a/services/mgmt/node/impl/config_service.go
+++ b/services/mgmt/node/impl/config_service.go
@@ -12,6 +12,7 @@
 
 	"veyron.io/veyron/veyron2/ipc"
 	"veyron.io/veyron/veyron2/naming"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -64,7 +65,7 @@
 		return value, nil
 	case <-time.After(timeout):
 		vlog.Errorf("Waiting for callback timed out")
-		return "", errOperationFailed
+		return "", verror2.Make(ErrOperationFailed, nil)
 	}
 }
 
@@ -127,7 +128,7 @@
 	i.callback.Lock()
 	if _, ok := i.callback.channels[id]; !ok {
 		i.callback.Unlock()
-		return errInvalidSuffix
+		return verror2.Make(ErrInvalidSuffix, nil)
 	}
 	channel, ok := i.callback.channels[id][key]
 	i.callback.Unlock()
diff --git a/services/mgmt/node/impl/dispatcher.go b/services/mgmt/node/impl/dispatcher.go
index deeddcd..45b2bd2 100644
--- a/services/mgmt/node/impl/dispatcher.go
+++ b/services/mgmt/node/impl/dispatcher.go
@@ -29,6 +29,7 @@
 	"veyron.io/veyron/veyron2/services/mgmt/stats"
 	"veyron.io/veyron/veyron2/services/security/access"
 	"veyron.io/veyron/veyron2/verror"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -71,18 +72,19 @@
 	appsSuffix   = "apps"
 	nodeSuffix   = "nm"
 	configSuffix = "cfg"
+
+	pkgPath = "veyron.io/veyron/veyron/services/mgmt/node/impl"
 )
 
 var (
-	errInvalidSuffix      = verror.BadArgf("invalid suffix")
-	errOperationFailed    = verror.Internalf("operation failed")
-	errInProgress         = verror.Existsf("operation in progress")
-	errIncompatibleUpdate = verror.BadArgf("update failed: mismatching app title")
-	// TODO(bprosnitz) Remove the TODO blocks in util_test when these are upgraded to verror2
-	errUpdateNoOp       = verror.NoExistf("no different version available")
-	errNotExist         = verror.NoExistf("object does not exist")
-	errInvalidOperation = verror.BadArgf("invalid operation")
-	errInvalidBlessing  = verror.BadArgf("invalid claim blessing")
+	ErrInvalidSuffix       = verror2.Register(pkgPath+".InvalidSuffix", verror2.NoRetry, "")
+	ErrOperationFailed     = verror2.Register(pkgPath+".OperationFailed", verror2.NoRetry, "")
+	ErrOperationInProgress = verror2.Register(pkgPath+".OperationInProgress", verror2.NoRetry, "")
+	ErrAppTitleMismatch    = verror2.Register(pkgPath+".AppTitleMismatch", verror2.NoRetry, "")
+	ErrUpdateNoOp          = verror2.Register(pkgPath+".UpdateNoOp", verror2.NoRetry, "")
+	ErrObjectNoExist       = verror2.Register(pkgPath+".ObjectNoExist", verror2.NoRetry, "")
+	ErrInvalidOperation    = verror2.Register(pkgPath+".InvalidOperation", verror2.NoRetry, "")
+	ErrInvalidBlessing     = verror2.Register(pkgPath+".InvalidBlessing", verror2.NoRetry, "")
 )
 
 // NewDispatcher is the node manager dispatcher factory.
@@ -161,7 +163,7 @@
 	// TODO(rjkroege): Scrub the state tree of installation and instance ACL files.
 	if len(names) == 0 {
 		vlog.Errorf("No names for claimer(%v) are trusted", proof)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	rt.R().Principal().BlessingStore().Set(proof, security.AllPrincipals)
 	rt.R().Principal().BlessingStore().SetDefault(proof)
@@ -175,11 +177,11 @@
 	_, etag, err := d.getACL()
 	if err != nil {
 		vlog.Errorf("Failed to getACL:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err := d.setACL(acl, etag, true /* store ACL on disk */); err != nil {
 		vlog.Errorf("Failed to setACL:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -274,27 +276,27 @@
 	data, err := ioutil.TempFile(dir, "data")
 	if err != nil {
 		vlog.Errorf("Failed to open tmpfile data:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	defer os.Remove(data.Name())
 	sig, err := ioutil.TempFile(dir, "sig")
 	if err != nil {
 		vlog.Errorf("Failed to open tmpfile sig:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	defer os.Remove(sig.Name())
 	writer, err := serialization.NewSigningWriteCloser(data, sig, rt.R().Principal(), nil)
 	if err != nil {
 		vlog.Errorf("Failed to create NewSigningWriteCloser:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err = acl.WriteTo(writer); err != nil {
 		vlog.Errorf("Failed to SaveACL:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err = writer.Close(); err != nil {
 		vlog.Errorf("Failed to Close() SigningWriteCloser:%v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err := os.Rename(data.Name(), aclFile); err != nil {
 		return err
@@ -383,7 +385,7 @@
 					return nil, nil, err
 				}
 				if !instanceStateIs(appInstanceDir, started) {
-					return nil, nil, errInvalidSuffix
+					return nil, nil, verror2.Make(ErrInvalidSuffix, nil)
 				}
 				var sigStub signatureStub
 				if kind == "pprof" {
@@ -416,7 +418,7 @@
 		return receiver, appSpecificAuthorizer, nil
 	case configSuffix:
 		if len(components) != 2 {
-			return nil, nil, errInvalidSuffix
+			return nil, nil, verror2.Make(ErrInvalidSuffix, nil)
 		}
 		receiver := inode.ConfigServer(&configService{
 			callback: d.internal.callback,
@@ -431,7 +433,7 @@
 		// (and not other apps).
 		return receiver, nil, nil
 	default:
-		return nil, nil, errInvalidSuffix
+		return nil, nil, verror2.Make(ErrInvalidSuffix, nil)
 	}
 }
 
@@ -459,7 +461,7 @@
 		}
 		return access.TaggedACLAuthorizerFromFile(path.Join(p, "acls", "data"), access.TypicalTagType())
 	}
-	return nil, errInvalidSuffix
+	return nil, verror2.Make(ErrInvalidSuffix, nil)
 }
 
 // allowEveryone implements the authorization policy that allows all principals
diff --git a/services/mgmt/node/impl/impl_test.go b/services/mgmt/node/impl/impl_test.go
index 06eb18a..d753fd5 100644
--- a/services/mgmt/node/impl/impl_test.go
+++ b/services/mgmt/node/impl/impl_test.go
@@ -38,9 +38,9 @@
 	"veyron.io/veyron/veyron2/services/mgmt/pprof"
 	"veyron.io/veyron/veyron2/services/mgmt/stats"
 	"veyron.io/veyron/veyron2/services/security/access"
+	"veyron.io/veyron/veyron2/vdl/vdlutil"
 	"veyron.io/veyron/veyron2/verror"
 	"veyron.io/veyron/veyron2/vlog"
-	"veyron.io/veyron/veyron2/vom"
 
 	"veyron.io/veyron/veyron/lib/expect"
 	"veyron.io/veyron/veyron/lib/modules"
@@ -61,7 +61,7 @@
 
 func init() {
 	// TODO(rthellend): Remove when vom2 is ready.
-	vom.Register(&naming.VDLMountedServer{})
+	vdlutil.Register(&naming.VDLMountedServer{})
 
 	modules.RegisterChild(execScriptCmd, "", execScript)
 	modules.RegisterChild(nodeManagerCmd, "", nodeManager)
@@ -341,8 +341,8 @@
 	// Simulate an invalid envelope in the application repository.
 	*envelope = envelopeFromShell(sh, nmPauseBeforeStopEnv, nodeManagerCmd, "bogus", nmArgs...)
 
-	updateNodeExpectError(t, "factoryNM", verror.BadArg)  // Incorrect title.
-	revertNodeExpectError(t, "factoryNM", verror.NoExist) // No previous version available.
+	updateNodeExpectError(t, "factoryNM", impl.ErrAppTitleMismatch.ID)
+	revertNodeExpectError(t, "factoryNM", impl.ErrUpdateNoOp.ID)
 
 	// Set up a second version of the node manager. The information in the
 	// envelope will be used by the node manager to stage the next version.
@@ -364,7 +364,7 @@
 		t.Fatalf("current link didn't change")
 	}
 
-	updateNodeExpectError(t, "factoryNM", verror.Exists) // Update already in progress.
+	updateNodeExpectError(t, "factoryNM", impl.ErrOperationInProgress.ID)
 
 	nmh.CloseStdin()
 
@@ -382,7 +382,7 @@
 
 	// Try issuing an update without changing the envelope in the application
 	// repository: this should fail, and current link should be unchanged.
-	updateNodeExpectError(t, "v2NM", naming.ErrNoSuchName.ID)
+	updateNodeExpectError(t, "v2NM", impl.ErrUpdateNoOp.ID)
 	if evalLink() != scriptPathV2 {
 		t.Fatalf("script changed")
 	}
@@ -415,7 +415,7 @@
 
 	// Revert the node manager to its previous version (v2).
 	revertNode(t, "v3NM")
-	revertNodeExpectError(t, "v3NM", verror.Exists) // Revert already in progress.
+	revertNodeExpectError(t, "v3NM", impl.ErrOperationInProgress.ID) // Revert already in progress.
 	nmh.CloseStdin()
 	nms.Expect("v3NM terminating")
 	if evalLink() != scriptPathV2 {
@@ -554,8 +554,8 @@
 	appID := installApp(t)
 
 	// Start requires the caller to grant a blessing for the app instance.
-	if _, err := startAppImpl(t, appID, ""); err == nil || !verror.Is(err, verror.BadArg) {
-		t.Fatalf("Start(%v) expected to fail with %v, got %v instead", appID, verror.BadArg, err)
+	if _, err := startAppImpl(t, appID, ""); err == nil || !verror.Is(err, impl.ErrInvalidBlessing.ID) {
+		t.Fatalf("Start(%v) expected to fail with %v, got %v instead", appID, impl.ErrInvalidBlessing.ID, err)
 	}
 
 	// Start an instance of the app.
@@ -606,12 +606,12 @@
 	}
 
 	// Updating the installation to itself is a no-op.
-	updateAppExpectError(t, appID, naming.ErrNoSuchName.ID)
+	updateAppExpectError(t, appID, impl.ErrUpdateNoOp.ID)
 
 	// Updating the installation should not work with a mismatched title.
 	*envelope = envelopeFromShell(sh, nil, appCmd, "bogus")
 
-	updateAppExpectError(t, appID, verror.BadArg)
+	updateAppExpectError(t, appID, impl.ErrAppTitleMismatch.ID)
 
 	// Create a second version of the app and update the app to it.
 	*envelope = envelopeFromShell(sh, nil, appCmd, "google naps", "appV2")
@@ -673,19 +673,19 @@
 	resolveExpectNotFound(t, "appV1")
 
 	// We are already on the first version, no further revert possible.
-	revertAppExpectError(t, appID, naming.ErrNoSuchName.ID)
+	revertAppExpectError(t, appID, impl.ErrUpdateNoOp.ID)
 
 	// Uninstall the app.
 	uninstallApp(t, appID)
 
 	// Updating the installation should no longer be allowed.
-	updateAppExpectError(t, appID, verror.BadArg)
+	updateAppExpectError(t, appID, impl.ErrInvalidOperation.ID)
 
 	// Reverting the installation should no longer be allowed.
-	revertAppExpectError(t, appID, verror.BadArg)
+	revertAppExpectError(t, appID, impl.ErrInvalidOperation.ID)
 
 	// Starting new instances should no longer be allowed.
-	startAppExpectError(t, appID, verror.BadArg)
+	startAppExpectError(t, appID, impl.ErrInvalidOperation.ID)
 
 	// Cleanly shut down the node manager.
 	syscall.Kill(nmh.Pid(), syscall.SIGINT)
@@ -921,7 +921,7 @@
 	// sent to their children and so on.
 	pid := readPID(t, nms)
 	resolve(t, "nm", 1)
-	revertNodeExpectError(t, "nm", naming.ErrNoSuchName.ID) // No previous version available.
+	revertNodeExpectError(t, "nm", impl.ErrUpdateNoOp.ID) // No previous version available.
 	syscall.Kill(pid, syscall.SIGINT)
 
 	nms.Expect("nm terminating")
diff --git a/services/mgmt/node/impl/mock_repo_test.go b/services/mgmt/node/impl/mock_repo_test.go
index 6de199e..d55e2c9 100644
--- a/services/mgmt/node/impl/mock_repo_test.go
+++ b/services/mgmt/node/impl/mock_repo_test.go
@@ -3,7 +3,6 @@
 import (
 	"crypto/md5"
 	"encoding/hex"
-	"errors"
 	"io"
 	"io/ioutil"
 	"os"
@@ -13,6 +12,7 @@
 	"veyron.io/veyron/veyron2/services/mgmt/application"
 	"veyron.io/veyron/veyron2/services/mgmt/binary"
 	"veyron.io/veyron/veyron2/services/mgmt/repository"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -80,6 +80,11 @@
 
 // BINARY REPOSITORY INTERFACE IMPLEMENTATION
 
+// TODO(toddw): Move the errors from dispatcher.go into a common location.
+const pkgPath = "veyron.io/veyron/veyron/services/mgmt/node/impl"
+
+var ErrOperationFailed = verror2.Register(pkgPath+".OperationFailed", verror2.NoRetry, "")
+
 func (*brInvoker) Create(ipc.ServerContext, int32, repository.MediaInfo) error {
 	vlog.VI(1).Infof("Create()")
 	return nil
@@ -90,14 +95,12 @@
 	return nil
 }
 
-var errOperationFailed = errors.New("operation failed")
-
 func (i *brInvoker) Download(ctx repository.BinaryDownloadContext, _ int32) error {
 	vlog.VI(1).Infof("Download()")
 	file, err := os.Open(os.Args[0])
 	if err != nil {
 		vlog.Errorf("Open() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	defer file.Close()
 	bufferLength := 4096
@@ -111,11 +114,11 @@
 		case nil:
 			if err := sender.Send(buffer[:n]); err != nil {
 				vlog.Errorf("Send() failed: %v", err)
-				return errOperationFailed
+				return verror2.Make(ErrOperationFailed, ctx)
 			}
 		default:
 			vlog.Errorf("Read() failed: %v", err)
-			return errOperationFailed
+			return verror2.Make(ErrOperationFailed, ctx)
 		}
 	}
 }
@@ -125,12 +128,12 @@
 	return "", 0, nil
 }
 
-func (*brInvoker) Stat(ipc.ServerContext) ([]binary.PartInfo, repository.MediaInfo, error) {
+func (*brInvoker) Stat(ctx ipc.ServerContext) ([]binary.PartInfo, repository.MediaInfo, error) {
 	vlog.VI(1).Infof("Stat()")
 	h := md5.New()
 	bytes, err := ioutil.ReadFile(os.Args[0])
 	if err != nil {
-		return []binary.PartInfo{}, repository.MediaInfo{}, errOperationFailed
+		return []binary.PartInfo{}, repository.MediaInfo{}, verror2.Make(ErrOperationFailed, ctx)
 	}
 	h.Write(bytes)
 	part := binary.PartInfo{Checksum: hex.EncodeToString(h.Sum(nil)), Size: int64(len(bytes))}
diff --git a/services/mgmt/node/impl/node_service.go b/services/mgmt/node/impl/node_service.go
index 0d4799a..e99b5b3 100644
--- a/services/mgmt/node/impl/node_service.go
+++ b/services/mgmt/node/impl/node_service.go
@@ -47,6 +47,7 @@
 	"veyron.io/veyron/veyron2/services/mgmt/binary"
 	"veyron.io/veyron/veyron2/services/mgmt/node"
 	"veyron.io/veyron/veyron2/services/security/access"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 
 	vexec "veyron.io/veyron/veyron/lib/exec"
@@ -97,7 +98,7 @@
 	// Get the blessing to be used by the claimant.
 	blessings := call.Blessings()
 	if blessings == nil {
-		return errInvalidBlessing
+		return verror2.Make(ErrInvalidBlessing, call)
 	}
 	return i.disp.claimNodeManager(blessings.ForContext(call), blessings)
 }
@@ -220,7 +221,7 @@
 	// Start the child process.
 	if err := handle.Start(); err != nil {
 		vlog.Errorf("Start() failed: %v", err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	defer func() {
 		if err := handle.Clean(); err != nil {
@@ -230,40 +231,40 @@
 	// Wait for the child process to start.
 	if err := handle.WaitForReady(childReadyTimeout); err != nil {
 		vlog.Errorf("WaitForReady(%v) failed: %v", childReadyTimeout, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	childName, err := listener.waitForValue(childReadyTimeout)
 	if err != nil {
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	// Check that invoking Update() succeeds.
 	childName = naming.Join(childName, "nm")
 	nmClient := node.NodeClient(childName)
 	linkOld, pathOld, err := i.getCurrentFileInfo()
 	if err != nil {
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	// Since the resolution of mtime for files is seconds, the test sleeps
 	// for a second to make sure it can check whether the current symlink is
 	// updated.
 	time.Sleep(time.Second)
 	if err := nmClient.Revert(ctx); err != nil {
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	linkNew, pathNew, err := i.getCurrentFileInfo()
 	if err != nil {
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	// Check that the new node manager updated the current symbolic link.
 	if !linkOld.ModTime().Before(linkNew.ModTime()) {
 		vlog.Errorf("new node manager test failed")
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	// Ensure that the current symbolic link points to the same script.
 	if pathNew != pathOld {
 		updateLink(pathOld, i.config.CurrentLink)
 		vlog.Errorf("new node manager test failed")
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	return nil
 }
@@ -276,7 +277,7 @@
 	path, err := filepath.EvalSymlinks(os.Args[0])
 	if err != nil {
 		vlog.Errorf("EvalSymlinks(%v) failed: %v", os.Args[0], err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 
 	output := "#!/bin/bash\n"
@@ -292,31 +293,31 @@
 	path = filepath.Join(workspace, "noded.sh")
 	if err := ioutil.WriteFile(path, []byte(output), 0700); err != nil {
 		vlog.Errorf("WriteFile(%v) failed: %v", path, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
 
 func (i *nodeService) updateNodeManager(ctx context.T) error {
 	if len(i.config.Origin) == 0 {
-		return errUpdateNoOp
+		return verror2.Make(ErrUpdateNoOp, ctx)
 	}
 	envelope, err := fetchEnvelope(ctx, i.config.Origin)
 	if err != nil {
 		return err
 	}
 	if envelope.Title != application.NodeManagerTitle {
-		return errIncompatibleUpdate
+		return verror2.Make(ErrAppTitleMismatch, ctx)
 	}
 	if i.config.Envelope != nil && reflect.DeepEqual(envelope, i.config.Envelope) {
-		return errUpdateNoOp
+		return verror2.Make(ErrUpdateNoOp, ctx)
 	}
 	// Create new workspace.
 	workspace := filepath.Join(i.config.Root, "node-manager", generateVersionDirName())
 	perm := os.FileMode(0700)
 	if err := os.MkdirAll(workspace, perm); err != nil {
 		vlog.Errorf("MkdirAll(%v, %v) failed: %v", workspace, perm, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 
 	deferrer := func() {
@@ -345,7 +346,7 @@
 	// Populate the new workspace with a node manager script.
 	configSettings, err := i.config.Save(envelope)
 	if err != nil {
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 
 	if err := generateScript(workspace, configSettings, envelope); err != nil {
@@ -365,8 +366,8 @@
 	return nil
 }
 
-func (*nodeService) Install(ipc.ServerContext, string) (string, error) {
-	return "", errInvalidSuffix
+func (*nodeService) Install(ctx ipc.ServerContext, _ string) (string, error) {
+	return "", verror2.Make(ErrInvalidSuffix, ctx)
 }
 
 func (*nodeService) Refresh(ipc.ServerContext) error {
@@ -379,17 +380,17 @@
 	return nil
 }
 
-func (*nodeService) Resume(ipc.ServerContext) error {
-	return errInvalidSuffix
+func (*nodeService) Resume(ctx ipc.ServerContext) error {
+	return verror2.Make(ErrInvalidSuffix, ctx)
 }
 
 func (i *nodeService) Revert(call ipc.ServerContext) error {
 	if i.config.Previous == "" {
-		return errUpdateNoOp
+		return verror2.Make(ErrUpdateNoOp, call)
 	}
 	updatingState := i.updating
 	if updatingState.testAndSetUpdating() {
-		return errInProgress
+		return verror2.Make(ErrOperationInProgress, call)
 	}
 	err := i.revertNodeManager()
 	if err != nil {
@@ -398,12 +399,12 @@
 	return err
 }
 
-func (*nodeService) Start(ipc.ServerContext) ([]string, error) {
-	return nil, errInvalidSuffix
+func (*nodeService) Start(ctx ipc.ServerContext) ([]string, error) {
+	return nil, verror2.Make(ErrInvalidSuffix, ctx)
 }
 
-func (*nodeService) Stop(ipc.ServerContext, uint32) error {
-	return errInvalidSuffix
+func (*nodeService) Stop(ctx ipc.ServerContext, _ uint32) error {
+	return verror2.Make(ErrInvalidSuffix, ctx)
 }
 
 func (*nodeService) Suspend(ipc.ServerContext) error {
@@ -411,17 +412,17 @@
 	return nil
 }
 
-func (*nodeService) Uninstall(ipc.ServerContext) error {
-	return errInvalidSuffix
+func (*nodeService) Uninstall(ctx ipc.ServerContext) error {
+	return verror2.Make(ErrInvalidSuffix, ctx)
 }
 
-func (i *nodeService) Update(ipc.ServerContext) error {
+func (i *nodeService) Update(call ipc.ServerContext) error {
 	ctx, cancel := rt.R().NewContext().WithTimeout(ipcContextTimeout)
 	defer cancel()
 
 	updatingState := i.updating
 	if updatingState.testAndSetUpdating() {
-		return errInProgress
+		return verror2.Make(ErrOperationInProgress, call)
 	}
 
 	err := i.updateNodeManager(ctx)
@@ -444,13 +445,13 @@
 	return i.disp.getACL()
 }
 
-func sameMachineCheck(call ipc.ServerContext) error {
-	switch local, err := netstate.SameMachine(call.RemoteEndpoint().Addr()); {
+func sameMachineCheck(ctx ipc.ServerContext) error {
+	switch local, err := netstate.SameMachine(ctx.RemoteEndpoint().Addr()); {
 	case err != nil:
 		return err
 	case local == false:
 		vlog.Errorf("SameMachine() indicates that endpoint is not on the same node")
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, ctx)
 	}
 	return nil
 }
diff --git a/services/mgmt/node/impl/util.go b/services/mgmt/node/impl/util.go
index 8446506..f700552 100644
--- a/services/mgmt/node/impl/util.go
+++ b/services/mgmt/node/impl/util.go
@@ -13,6 +13,7 @@
 	"veyron.io/veyron/veyron2/rt"
 	"veyron.io/veyron/veyron2/services/mgmt/application"
 	"veyron.io/veyron/veyron2/services/mgmt/repository"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 )
 
@@ -26,12 +27,12 @@
 	data, _, err := binary.Download(rt.R().NewContext(), name)
 	if err != nil {
 		vlog.Errorf("Download(%v) failed: %v", name, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	path, perm := filepath.Join(workspace, fileName), os.FileMode(755)
 	if err := ioutil.WriteFile(path, data, perm); err != nil {
 		vlog.Errorf("WriteFile(%v, %v) failed: %v", path, perm, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -44,7 +45,7 @@
 	envelope, err := stub.Match(ctx, profiles)
 	if err != nil {
 		vlog.Errorf("Match(%v) failed: %v", profiles, err)
-		return nil, errOperationFailed
+		return nil, verror2.Make(ErrOperationFailed, ctx)
 	}
 	return &envelope, nil
 }
@@ -55,7 +56,7 @@
 	self := os.Args[0]
 	if err := os.Link(self, path); err != nil {
 		vlog.Errorf("Link(%v, %v) failed: %v", self, path, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
@@ -70,16 +71,16 @@
 	if err == nil {
 		if err := os.Remove(fi.Name()); err != nil {
 			vlog.Errorf("Remove(%v) failed: %v", fi.Name(), err)
-			return errOperationFailed
+			return verror2.Make(ErrOperationFailed, nil)
 		}
 	}
 	if err := os.Symlink(target, newLink); err != nil {
 		vlog.Errorf("Symlink(%v, %v) failed: %v", target, newLink, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	if err := os.Rename(newLink, link); err != nil {
 		vlog.Errorf("Rename(%v, %v) failed: %v", newLink, link, err)
-		return errOperationFailed
+		return verror2.Make(ErrOperationFailed, nil)
 	}
 	return nil
 }
diff --git a/services/mgmt/node/impl/util_test.go b/services/mgmt/node/impl/util_test.go
index ed1b555..52e1af6 100644
--- a/services/mgmt/node/impl/util_test.go
+++ b/services/mgmt/node/impl/util_test.go
@@ -19,6 +19,7 @@
 	"veyron.io/veyron/veyron2/security"
 	"veyron.io/veyron/veyron2/services/mgmt/node"
 	"veyron.io/veyron/veyron2/verror"
+	"veyron.io/veyron/veyron2/verror2"
 	"veyron.io/veyron/veyron2/vlog"
 
 	"veyron.io/veyron/veyron/lib/expect"
@@ -168,7 +169,7 @@
 func resolveExpectNotFound(t *testing.T, name string) {
 	if results, err := rt.R().Namespace().Resolve(rt.R().NewContext(), name); err == nil {
 		t.Fatalf("Resolve(%v) succeeded with results %v when it was expected to fail", name, results)
-	} else if expectErr := naming.ErrNoSuchName.ID; !verror.Is(err, expectErr) {
+	} else if expectErr := naming.ErrNoSuchName.ID; !verror2.Is(err, expectErr) {
 		t.Fatalf("Resolve(%v) failed with error %v, expected error ID %v", name, err, expectErr)
 	}
 }
@@ -202,11 +203,7 @@
 }
 
 func updateNodeExpectError(t *testing.T, name string, errID verror.ID) {
-	if err := nodeStub(name).Update(rt.R().NewContext()); !verror.Is(err, errID) {
-		if errID == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
-			// TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
-			return
-		}
+	if err := nodeStub(name).Update(rt.R().NewContext()); !verror2.Is(err, errID) {
 		t.Fatalf("%s: Update(%v) expected to fail with %v, got %v instead", loc(1), name, errID, err)
 	}
 }
@@ -218,11 +215,7 @@
 }
 
 func revertNodeExpectError(t *testing.T, name string, errID verror.ID) {
-	if err := nodeStub(name).Revert(rt.R().NewContext()); !verror.Is(err, errID) {
-		if errID == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
-			// TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
-			return
-		}
+	if err := nodeStub(name).Revert(rt.R().NewContext()); !verror2.Is(err, errID) {
 		t.Fatalf("%s: Revert(%v) expected to fail with %v, got %v instead", loc(1), name, errID, err)
 	}
 }
@@ -292,7 +285,7 @@
 }
 
 func startAppExpectError(t *testing.T, appID string, expectedError verror.ID, opt ...veyron2.Runtime) {
-	if _, err := startAppImpl(t, appID, "forapp", opt...); err == nil || !verror.Is(err, expectedError) {
+	if _, err := startAppImpl(t, appID, "forapp", opt...); err == nil || !verror2.Is(err, expectedError) {
 		t.Fatalf("%s: Start(%v) expected to fail with %v, got %v instead", loc(1), appID, expectedError, err)
 	}
 }
@@ -316,7 +309,7 @@
 }
 
 func resumeAppExpectError(t *testing.T, appID, instanceID string, expectedError verror.ID, opt ...veyron2.Runtime) {
-	if err := appStub(appID, instanceID).Resume(ort(opt).NewContext()); err == nil || !verror.Is(err, expectedError) {
+	if err := appStub(appID, instanceID).Resume(ort(opt).NewContext()); err == nil || !verror2.Is(err, expectedError) {
 		t.Fatalf("%s: Resume(%v/%v) expected to fail with %v, got %v instead", loc(1), appID, instanceID, expectedError, err)
 	}
 }
@@ -328,11 +321,7 @@
 }
 
 func updateAppExpectError(t *testing.T, appID string, expectedError verror.ID) {
-	if err := appStub(appID).Update(rt.R().NewContext()); err == nil || !verror.Is(err, expectedError) {
-		if expectedError == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
-			// TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
-			return
-		}
+	if err := appStub(appID).Update(rt.R().NewContext()); err == nil || !verror2.Is(err, expectedError) {
 		t.Fatalf("%s: Update(%v) expected to fail with %v, got %v instead", loc(1), appID, expectedError, err)
 	}
 }
@@ -344,11 +333,7 @@
 }
 
 func revertAppExpectError(t *testing.T, appID string, expectedError verror.ID) {
-	if err := appStub(appID).Revert(rt.R().NewContext()); err == nil || !verror.Is(err, expectedError) {
-		if expectedError == naming.ErrNoSuchName.ID && err.Error() == "no different version available" {
-			// TODO(bprosnitz) Remove this check when errUpdateNoOp is updated to verror2
-			return
-		}
+	if err := appStub(appID).Revert(rt.R().NewContext()); err == nil || !verror2.Is(err, expectedError) {
 		t.Fatalf("%s: Revert(%v) expected to fail with %v, got %v instead", loc(1), appID, expectedError, err)
 	}
 }
diff --git a/services/mgmt/profile/profile.vdl.go b/services/mgmt/profile/profile.vdl.go
index 97c0689..d3c766c 100644
--- a/services/mgmt/profile/profile.vdl.go
+++ b/services/mgmt/profile/profile.vdl.go
@@ -7,6 +7,9 @@
 
 import (
 	"veyron.io/veyron/veyron2/services/mgmt/build"
+
+	// The non-user imports are prefixed with "__" to prevent collisions.
+	__vdl "veyron.io/veyron/veyron2/vdl"
 )
 
 // Library describes a shared library that applications may use.
@@ -19,6 +22,11 @@
 	MinorVersion string
 }
 
+func (Library) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/services/mgmt/profile.Library"
+}) {
+}
+
 // Specification is how we represent a profile internally. It should
 // provide enough information to allow matching of binaries to nodes.
 type Specification struct {
@@ -36,3 +44,13 @@
 	// OS is the target operating system of the profile.
 	OS build.OperatingSystem
 }
+
+func (Specification) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/services/mgmt/profile.Specification"
+}) {
+}
+
+func init() {
+	__vdl.Register(Library{})
+	__vdl.Register(Specification{})
+}
diff --git a/services/mgmt/stats/impl/stats_test.go b/services/mgmt/stats/impl/stats_test.go
index 6b526f6..5555d2c 100644
--- a/services/mgmt/stats/impl/stats_test.go
+++ b/services/mgmt/stats/impl/stats_test.go
@@ -107,6 +107,8 @@
 
 	// Test WatchGlob()
 	{
+		noRM := types.ResumeMarker{}
+		_ = noRM
 		stream, err := c.WatchGlob(rt.R().NewContext(), types.GlobRequest{Pattern: "testing/foo/bar"})
 		if err != nil {
 			t.Fatalf("c.WatchGlob failed: %v", err)
@@ -116,6 +118,8 @@
 			t.Fatalf("expected more stream values")
 		}
 		got := iterator.Value()
+		// TODO(toddw): This change is necessary for vom2:
+		//expected := types.Change{Name: "testing/foo/bar", Value: int64(10), ResumeMarker: noRM}
 		expected := types.Change{Name: "testing/foo/bar", Value: int64(10)}
 		if !reflect.DeepEqual(got, expected) {
 			t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
@@ -127,6 +131,8 @@
 			t.Fatalf("expected more stream values")
 		}
 		got = iterator.Value()
+		// TODO(toddw): This change is necessary for vom2:
+		//expected := types.Change{Name: "testing/foo/bar", Value: int64(15), ResumeMarker: noRM}
 		expected = types.Change{Name: "testing/foo/bar", Value: int64(15)}
 		if !reflect.DeepEqual(got, expected) {
 			t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
@@ -138,6 +144,8 @@
 			t.Fatalf("expected more stream values")
 		}
 		got = iterator.Value()
+		// TODO(toddw): This change is necessary for vom2:
+		//expected := types.Change{Name: "testing/foo/bar", Value: int64(17), ResumeMarker: noRM}
 		expected = types.Change{Name: "testing/foo/bar", Value: int64(17)}
 		if !reflect.DeepEqual(got, expected) {
 			t.Errorf("unexpected result. Got %#v, want %#v", got, expected)
diff --git a/services/mgmt/stats/types.vdl.go b/services/mgmt/stats/types.vdl.go
index 7ad330c..cc41c75 100644
--- a/services/mgmt/stats/types.vdl.go
+++ b/services/mgmt/stats/types.vdl.go
@@ -4,6 +4,11 @@
 // Packages stats defines the non-native types exported by the stats service.
 package stats
 
+import (
+	// The non-user imports are prefixed with "__" to prevent collisions.
+	__vdl "veyron.io/veyron/veyron2/vdl"
+)
+
 // HistogramValue is the value of Histogram objects.
 type HistogramValue struct {
 	// Count is the total number of values added to the histogram.
@@ -14,6 +19,11 @@
 	Buckets []HistogramBucket
 }
 
+func (HistogramValue) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/services/mgmt/stats.HistogramValue"
+}) {
+}
+
 // HistogramBucket is one histogram bucket.
 type HistogramBucket struct {
 	// LowBound is the lower bound of the bucket.
@@ -21,3 +31,13 @@
 	// Count is the number of values in the bucket.
 	Count int64
 }
+
+func (HistogramBucket) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/services/mgmt/stats.HistogramBucket"
+}) {
+}
+
+func init() {
+	__vdl.Register(HistogramValue{})
+	__vdl.Register(HistogramBucket{})
+}
diff --git a/tools/debug/impl.go b/tools/debug/impl.go
index f201b5d..e36d950 100644
--- a/tools/debug/impl.go
+++ b/tools/debug/impl.go
@@ -27,7 +27,7 @@
 	"veyron.io/veyron/veyron2/services/watch"
 	watchtypes "veyron.io/veyron/veyron2/services/watch/types"
 	"veyron.io/veyron/veyron2/uniqueid"
-	"veyron.io/veyron/veyron2/vom"
+	"veyron.io/veyron/veyron2/vdl/vdlutil"
 	"veyron.io/veyron/veyron2/vtrace"
 )
 
@@ -42,7 +42,7 @@
 )
 
 func init() {
-	vom.Register(istats.HistogramValue{})
+	vdlutil.Register(istats.HistogramValue{})
 
 	// logs read flags
 	cmdLogsRead.Flags.BoolVar(&follow, "f", false, "When true, read will wait for new log entries when it reaches the end of the file.")
diff --git a/tools/mgmt/nodex/acl_test.go b/tools/mgmt/nodex/acl_test.go
index 1b2a332..25aec7e 100644
--- a/tools/mgmt/nodex/acl_test.go
+++ b/tools/mgmt/nodex/acl_test.go
@@ -4,6 +4,7 @@
 	"bytes"
 	"fmt"
 	"reflect"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -226,8 +227,8 @@
 	if err := cmd.Execute([]string{"acl", "set", nodeName, "vana/bad", "Read"}); err == nil {
 		t.Fatalf("GetACL RPC inside acl set command failed but error wrongly not detected")
 	}
-	if expected, got := "ERROR: GetACL("+nodeName+") failed: oops!", strings.TrimSpace(stderr.String()); !strings.HasPrefix(got, expected) {
-		t.Fatalf("Unexpected output from list. Got %q, prefix %q", got, expected)
+	if expected, got := `^ERROR: GetACL\(`+nodeName+`\) failed:.*oops!`, strings.TrimSpace(stderr.String()); !regexp.MustCompile(expected).MatchString(got) {
+		t.Fatalf("Unexpected output from list. Got %q, regexp %q", got, expected)
 	}
 	if expected, got := "", strings.TrimSpace(stdout.String()); got != expected {
 		t.Fatalf("Unexpected output from list. Got %q, expected %q", got, expected)
@@ -262,8 +263,8 @@
 	if expected, got := "", strings.TrimSpace(stdout.String()); got != expected {
 		t.Fatalf("Unexpected output from list. Got %q, expected %q", got, expected)
 	}
-	if expected, got := "ERROR: SetACL("+nodeName+") failed: oops!", strings.TrimSpace(stderr.String()); !strings.HasPrefix(got, expected) {
-		t.Fatalf("Unexpected output from list. Got %q, prefix %q", got, expected)
+	if expected, got := `^ERROR: SetACL\(`+nodeName+`\) failed:.*oops!`, strings.TrimSpace(stderr.String()); !regexp.MustCompile(expected).MatchString(got) {
+		t.Fatalf("Unexpected output from list. Got %q, regexp %q", got, expected)
 	}
 
 	expected = []interface{}{
diff --git a/tools/vrpc/impl.go b/tools/vrpc/impl.go
index 4a87c67..3133ea4 100644
--- a/tools/vrpc/impl.go
+++ b/tools/vrpc/impl.go
@@ -121,15 +121,15 @@
 	// Benj implements support for decoding arbitrary structs to an
 	// empty interface, this will no longer be needed.
 	var x1 idl_test_base.Struct
-	vom.Register(x1)
+	vdlutil.Register(x1)
 	var x2 idl_node.Description
-	vom.Register(x2)
+	vdlutil.Register(x2)
 	var x3 idl_binary.Description
-	vom.Register(x3)
+	vdlutil.Register(x3)
 	var x4 naming.VDLMountedServer
-	vom.Register(x4)
+	vdlutil.Register(x4)
 	var x5 naming.VDLMountEntry
-	vom.Register(x5)
+	vdlutil.Register(x5)
 
 	// Decode the inputs from vomJSON-formatted command-line arguments.
 	inputs := make([]interface{}, len(args))
diff --git a/tools/vrpc/test_base/test_base.vdl.go b/tools/vrpc/test_base/test_base.vdl.go
index eec0c49..a411da3 100644
--- a/tools/vrpc/test_base/test_base.vdl.go
+++ b/tools/vrpc/test_base/test_base.vdl.go
@@ -9,6 +9,7 @@
 	__veyron2 "veyron.io/veyron/veyron2"
 	__context "veyron.io/veyron/veyron2/context"
 	__ipc "veyron.io/veyron/veyron2/ipc"
+	__vdl "veyron.io/veyron/veyron2/vdl"
 	__vdlutil "veyron.io/veyron/veyron2/vdl/vdlutil"
 	__wiretype "veyron.io/veyron/veyron2/wiretype"
 )
@@ -23,6 +24,15 @@
 	Y int32
 }
 
+func (Struct) __VDLReflect(struct {
+	Name string "veyron.io/veyron/veyron/tools/vrpc/test_base.Struct"
+}) {
+}
+
+func init() {
+	__vdl.Register(Struct{})
+}
+
 // TypeTesterClientMethods is the client interface
 // containing TypeTester methods.
 type TypeTesterClientMethods interface {