diff --git a/lib/unixfd/unixfd.go b/lib/unixfd/unixfd.go
new file mode 100644
index 0000000..2fa870f
--- /dev/null
+++ b/lib/unixfd/unixfd.go
@@ -0,0 +1,133 @@
+// Package unixfd provides provides support for Dialing and Listening
+// on already connected file descriptors (like those returned by socketpair).
+package unixfd
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"os"
+	"strconv"
+	"sync"
+	"syscall"
+	"veyron2/ipc/stream"
+)
+
+const Network string = "unixfd"
+
+// singleConnListener implements net.Listener for an already-connected socket.
+// This is different from net.FileListener, which calls syscall.Listen
+// on an unconnected socket.
+type singleConnListener struct {
+	c    chan net.Conn
+	addr net.Addr
+	sync.Mutex
+}
+
+func (l *singleConnListener) getChan() chan net.Conn {
+	l.Lock()
+	defer l.Unlock()
+	return l.c
+}
+
+func (l *singleConnListener) Accept() (net.Conn, error) {
+	c := l.getChan()
+	if c == nil {
+		return nil, errors.New("listener closed")
+	}
+	if conn, ok := <-c; ok {
+		return conn, nil
+	}
+	return nil, io.EOF
+}
+
+func (l *singleConnListener) Close() error {
+	l.Lock()
+	defer l.Unlock()
+	lc := l.c
+	if lc == nil {
+		return errors.New("listener already closed")
+	}
+	close(l.c)
+	l.c = nil
+	// If the socket was never Accept'ed we need to close it.
+	if c, ok := <-lc; ok {
+		return c.Close()
+	}
+	return nil
+}
+
+func (l *singleConnListener) Addr() net.Addr {
+	return l.addr
+}
+
+func unixFDConn(address string) (net.Conn, error) {
+	fd, err := strconv.ParseInt(address, 10, 32)
+	if err != nil {
+		return nil, err
+	}
+	file := os.NewFile(uintptr(fd), "tmp")
+	conn, err := net.FileConn(file)
+	// 'file' is not used after this point, but we keep it open
+	// so that 'address' remains valid.
+	if err != nil {
+		file.Close()
+		return nil, err
+	}
+	// We wrap 'conn' so we can customize the address, and also
+	// to close 'file'.
+	return &fdConn{addr(address), file, conn}, nil
+}
+
+type fdConn struct {
+	addr net.Addr
+	sock *os.File
+	net.Conn
+}
+
+func (c *fdConn) Close() (err error) {
+	defer c.sock.Close()
+	return c.Conn.Close()
+}
+
+func (c *fdConn) LocalAddr() net.Addr {
+	return c.addr
+}
+
+func (c *fdConn) RemoteAddr() net.Addr {
+	return c.addr
+}
+
+func unixFDListen(address string) (net.Listener, error) {
+	conn, err := unixFDConn(address)
+	if err != nil {
+		return nil, err
+	}
+	c := make(chan net.Conn, 1)
+	c <- conn
+	return &singleConnListener{c, conn.LocalAddr(), sync.Mutex{}}, nil
+}
+
+type addr string
+
+func (a addr) Network() string { return Network }
+func (a addr) String() string  { return string(a) }
+
+// Addr returns a net.Addr for the unixfd network for the given file descriptor.
+func Addr(fd uintptr) net.Addr {
+	return addr(fmt.Sprintf("%d", fd))
+}
+
+// Socketpair returns two connected unix domain sockets, or an error.
+func Socketpair() ([]*os.File, error) {
+	fds, err := syscall.Socketpair(syscall.AF_UNIX, syscall.SOCK_STREAM, 0)
+	if err != nil {
+		return nil, err
+	}
+	return []*os.File{os.NewFile(uintptr(fds[0]), "local"), os.NewFile(uintptr(fds[1]), "remote")}, nil
+}
+
+func init() {
+	stream.RegisterProtocol(Network, unixFDConn, unixFDListen)
+}
diff --git a/lib/unixfd/unixfd_test.go b/lib/unixfd/unixfd_test.go
new file mode 100644
index 0000000..dd46ce9
--- /dev/null
+++ b/lib/unixfd/unixfd_test.go
@@ -0,0 +1,127 @@
+package unixfd
+
+import (
+	"bytes"
+	"io"
+	"net"
+	"os"
+	"reflect"
+	"testing"
+)
+
+type nothing struct{}
+
+func dial(fd *os.File) (net.Conn, error) {
+	addr := Addr(fd.Fd())
+	return unixFDConn(addr.String())
+}
+
+func listen(fd *os.File) (net.Listener, error) {
+	addr := Addr(fd.Fd())
+	return unixFDListen(addr.String())
+}
+
+func testWrite(t *testing.T, c net.Conn, data string) {
+	n, err := c.Write([]byte(data))
+	if err != nil {
+		t.Errorf("Write: %v", err)
+		return
+	}
+	if n != len(data) {
+		t.Errorf("Wrote %d bytes, expected %d", n, len(data))
+	}
+}
+
+func testRead(t *testing.T, c net.Conn, expected string) {
+	buf := make([]byte, len(expected)+2)
+	n, err := c.Read(buf)
+	if err != nil {
+		t.Errorf("Read: %v", err)
+		return
+	}
+	if n != len(expected) || !bytes.Equal(buf[0:n], []byte(expected)) {
+		t.Errorf("got %q, expected %q", buf[0:n], expected)
+	}
+}
+
+func TestDial(t *testing.T) {
+	fds, err := Socketpair()
+	if err != nil {
+		t.Fatalf("socketpair: %v", err)
+	}
+	a, err := dial(fds[0])
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	b, err := dial(fds[1])
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+
+	testWrite(t, a, "TEST1")
+	testRead(t, b, "TEST1")
+	testWrite(t, b, "TEST2")
+	testRead(t, a, "TEST2")
+
+	if !reflect.DeepEqual(a.LocalAddr(), Addr(fds[0].Fd())) {
+		t.Errorf("Invalid address %v, expected %d", a.LocalAddr(), fds[0].Fd())
+	}
+	if !reflect.DeepEqual(a.RemoteAddr(), Addr(fds[0].Fd())) {
+		t.Errorf("Invalid address %v, expected %d", a.RemoteAddr(), fds[0].Fd())
+	}
+	if !reflect.DeepEqual(b.LocalAddr(), Addr(fds[1].Fd())) {
+		t.Errorf("Invalid address %v, expected %d", a.LocalAddr(), fds[1].Fd())
+	}
+	if !reflect.DeepEqual(b.RemoteAddr(), Addr(fds[1].Fd())) {
+		t.Errorf("Invalid address %v, expected %d", a.RemoteAddr(), fds[1].Fd())
+	}
+}
+
+func TestListen(t *testing.T) {
+	fds, err := Socketpair()
+	if err != nil {
+		t.Fatalf("socketpair: %v", err)
+	}
+	a, err := dial(fds[0])
+	if err != nil {
+		t.Fatalf("dial: %v", err)
+	}
+	l, err := listen(fds[1])
+	if err != nil {
+		t.Fatalf("listen: %v", err)
+	}
+	b, err := l.Accept()
+	if err != nil {
+		t.Fatalf("accept: %v", err)
+	}
+	start := make(chan nothing, 0)
+	done := make(chan nothing)
+	go func() {
+		defer close(done)
+		<-start
+		if _, err := l.Accept(); err != io.EOF {
+			t.Fatalf("accept: expected EOF, got %v", err)
+		}
+	}()
+
+	// block until the goroutine starts running
+	start <- nothing{}
+	testWrite(t, a, "LISTEN")
+	testRead(t, b, "LISTEN")
+
+	err = l.Close()
+	if err != nil {
+		t.Fatalf("close: %v", err)
+	}
+	<-done
+
+	// After closed, accept should fail immediately
+	_, err = l.Accept()
+	if err == nil {
+		t.Fatalf("Accept succeeded after close")
+	}
+	err = l.Close()
+	if err == nil {
+		t.Fatalf("Close succeeded twice")
+	}
+}
diff --git a/runtimes/google/rt/security.go b/runtimes/google/rt/security.go
index a69b33c..8325c02 100644
--- a/runtimes/google/rt/security.go
+++ b/runtimes/google/rt/security.go
@@ -5,10 +5,14 @@
 	"os"
 	"os/user"
 
+	"veyron/lib/unixfd"
 	isecurity "veyron/runtimes/google/security"
 	vsecurity "veyron/security"
+	"veyron/security/agent"
 
+	"veyron2"
 	"veyron2/security"
+	"veyron2/verror"
 	"veyron2/vlog"
 )
 
@@ -50,7 +54,10 @@
 		return nil
 	}
 	var err error
-	if file := os.Getenv("VEYRON_IDENTITY"); len(file) > 0 {
+	if len(os.Getenv(agent.EndpointVarName)) > 0 {
+		rt.id, err = rt.connectToAgent()
+		return err
+	} else if file := os.Getenv("VEYRON_IDENTITY"); len(file) > 0 {
 		if rt.id, err = loadIdentityFromFile(file); err != nil || rt.id == nil {
 			return fmt.Errorf("Could not load identity from the VEYRON_IDENTITY environment variable (%q): %v", file, err)
 		}
@@ -105,3 +112,25 @@
 	defer f.Close()
 	return vsecurity.LoadIdentity(f)
 }
+
+func (rt *vrt) connectToAgent() (security.PrivateID, error) {
+	// Verify we're communicating over unix domain sockets so
+	// we know it's safe to use VCSecurityNone.
+	endpoint, err := rt.NewEndpoint(os.Getenv(agent.EndpointVarName))
+	if err != nil {
+		return nil, err
+	}
+	if endpoint.Addr().Network() != unixfd.Network {
+		return nil, verror.BadArgf("invalid agent address %v", endpoint.Addr())
+	}
+
+	client, err := rt.NewClient(veyron2.VCSecurityNone)
+	if err != nil {
+		return nil, err
+	}
+	signer, err := agent.NewAgentSigner(client, endpoint.String(), rt.NewContext())
+	if err != nil {
+		return nil, err
+	}
+	return isecurity.NewPrivateID("selfSigned", signer)
+}
diff --git a/security/agent/agent_test.go b/security/agent/agent_test.go
new file mode 100644
index 0000000..f2e46b2
--- /dev/null
+++ b/security/agent/agent_test.go
@@ -0,0 +1,85 @@
+package agent_test
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"os"
+	"reflect"
+	"testing"
+	"veyron/security/agent"
+	"veyron/security/agent/server"
+	"veyron2"
+	"veyron2/rt"
+	"veyron2/security"
+)
+
+type fakesigner struct {
+	key security.PublicKey
+}
+
+type testdata struct {
+	server_conn os.File
+	agent       security.Signer
+	signer      fakesigner
+}
+
+func setup() *testdata {
+	runtime := rt.Init()
+	result := &testdata{signer: newFakeSigner()}
+	sock, err := server.RunAnonymousAgent(runtime, result.signer)
+	if err != nil {
+		panic(err)
+	}
+	defer sock.Close()
+	client, err := runtime.NewClient(veyron2.VCSecurityNone)
+	if err != nil {
+		panic(err)
+	}
+	if agent, err := agent.NewAgentSigner(client, agent.CreateAgentEndpoint(int(sock.Fd())), runtime.NewContext()); err == nil {
+		result.agent = agent
+		return result
+	} else {
+		panic(err)
+	}
+}
+
+func TestSignature(t *testing.T) {
+	td := setup()
+	sig, err := td.agent.Sign(nil, []byte("abc"))
+
+	if err != nil {
+		t.Error(err)
+	}
+	expected := security.Signature{R: []byte{6}, S: []byte{7}}
+	if !reflect.DeepEqual(sig, expected) {
+		t.Errorf("Bad signature. Got\n%#v\nExpected:\n%#v", sig, expected)
+	}
+}
+
+func TestPublicKey(t *testing.T) {
+	td := setup()
+	expected_key := td.signer.PublicKey()
+	agent_key := td.agent.PublicKey()
+	if !reflect.DeepEqual(expected_key, agent_key) {
+		t.Errorf("Different keys: %v, %v", expected_key, agent_key)
+	}
+}
+
+func newFakeSigner() fakesigner {
+	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		panic(err)
+	}
+	return fakesigner{security.NewECDSAPublicKey(&key.PublicKey)}
+}
+
+func (fakesigner) Sign(message []byte) (security.Signature, error) {
+	var sig security.Signature
+	sig.R, sig.S = []byte{6}, []byte{7}
+	return sig, nil
+}
+
+func (s fakesigner) PublicKey() security.PublicKey {
+	return s.key
+}
diff --git a/security/agent/agentd/main.go b/security/agent/agentd/main.go
new file mode 100644
index 0000000..9538b1e
--- /dev/null
+++ b/security/agent/agentd/main.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"syscall"
+	"veyron/security/agent"
+	"veyron/security/agent/server"
+	"veyron2/rt"
+)
+
+func main() {
+	flag.Usage = func() {
+		fmt.Fprintf(os.Stderr, `Usage: %s [agent options] command command_args...
+
+Loads the identity specified in VEYRON_IDENTITY into memory, then
+starts the specified command with access to the identity via the
+agent protocol instead of directly reading from disk.
+
+`, os.Args[0])
+		flag.PrintDefaults()
+	}
+	// Load the identity specified in the environment
+	runtime := rt.Init()
+	log := runtime.Logger()
+
+	if len(flag.Args()) < 1 {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	var err error
+	if err = os.Setenv(agent.EndpointVarName, agent.CreateAgentEndpoint(3)); err != nil {
+		log.Fatalf("setenv: %v", err)
+	}
+	if err = os.Setenv("VEYRON_IDENTITY", ""); err != nil {
+		log.Fatalf("setenv: %v", err)
+	}
+
+	// Start running our server.
+	var sock *os.File
+	if sock, err = server.RunAnonymousAgent(runtime, runtime.Identity()); err != nil {
+		log.Fatalf("RunAgent: %v", err)
+	}
+
+	// Now run the client and wait for it to finish.
+	cmd := exec.Command(flag.Args()[0], flag.Args()[1:]...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.ExtraFiles = []*os.File{sock}
+
+	err = cmd.Start()
+	if err != nil {
+		log.Fatalf("Error starting child: %v", err)
+	}
+	sock.Close()
+	cmd.Wait()
+	status := cmd.ProcessState.Sys().(syscall.WaitStatus)
+	os.Exit(status.ExitStatus())
+}
diff --git a/security/agent/client.go b/security/agent/client.go
new file mode 100644
index 0000000..cb32acc
--- /dev/null
+++ b/security/agent/client.go
@@ -0,0 +1,72 @@
+// Package agent provides a client for communicating with an "Agent"
+// process holding the private key for an identity.
+package agent
+
+import (
+	"fmt"
+	"strconv"
+
+	"veyron/lib/unixfd"
+	"veyron2/context"
+	"veyron2/ipc"
+	"veyron2/naming"
+	"veyron2/security"
+	"veyron2/security/wire"
+)
+
+// EndpointVarName is the name of the environment variable containing
+// the endpoint for talking to the agent.
+const EndpointVarName = "VEYRON_AGENT_ENDPOINT"
+
+type client struct {
+	client ipc.Client
+	name   string
+	ctx    context.T
+	key    security.PublicKey
+}
+
+func (c *client) call(name string, result interface{}, args ...interface{}) (err error) {
+	var call ipc.Call
+	if call, err = c.client.StartCall(c.ctx, c.name, name, args); err == nil {
+		if ierr := call.Finish(result, &err); ierr != nil {
+			err = ierr
+		}
+	}
+	return
+}
+
+// NewAgentSigner returns a Signer using the PrivateKey held in a remote agent process.
+// 'ctx' should not have a deadline, and should never be cancelled.
+func NewAgentSigner(c ipc.Client, endpoint string, ctx context.T) (security.Signer, error) {
+	agent := &client{c, naming.JoinAddressName(endpoint, ""), ctx, nil}
+	if err := agent.fetchPublicKey(); err != nil {
+		return nil, err
+	}
+	return agent, nil
+}
+
+func (c *client) fetchPublicKey() (err error) {
+	var key wire.PublicKey
+	if err = c.call("PublicKey", &key); err != nil {
+		return
+	}
+	c.key, err = key.Decode()
+	return
+}
+
+func (c *client) PublicKey() security.PublicKey {
+	return c.key
+}
+
+func (c *client) Sign(purpose, message []byte) (sig security.Signature, err error) {
+	if purpose != nil {
+		err = fmt.Errorf("purpose not supported")
+		return
+	}
+	err = c.call("Sign", &sig, message)
+	return
+}
+
+func CreateAgentEndpoint(fd int) string {
+	return naming.FormatEndpoint(unixfd.Network, strconv.Itoa(fd))
+}
diff --git a/security/agent/server/server.go b/security/agent/server/server.go
new file mode 100644
index 0000000..71578d7
--- /dev/null
+++ b/security/agent/server/server.go
@@ -0,0 +1,65 @@
+// Package server provides a server which keeps a private key in memory
+// and allows clients to use the key for signing.
+package server
+
+import (
+	"os"
+	"veyron/lib/unixfd"
+	"veyron2"
+	"veyron2/ipc"
+	"veyron2/security"
+	"veyron2/security/wire"
+)
+
+type Signer interface {
+	Sign(message []byte) (security.Signature, error)
+	PublicKey() security.PublicKey
+}
+
+type agentd struct {
+	signer Signer
+}
+
+// RunAnonymousAgent starts the agent server listening on an
+// anonymous unix domain socket. It will respond to SignatureRequests
+// using 'signer'.
+// The returned 'client' is typically passed via cmd.ExtraFiles to a child process.
+func RunAnonymousAgent(runtime veyron2.Runtime, signer Signer) (client *os.File, err error) {
+	// VCSecurityNone is safe since we're using anonymous unix sockets.
+	// Only our child process can possibly communicate on the socket.
+	s, err := runtime.NewServer(veyron2.VCSecurityNone)
+	if err != nil {
+		return nil, err
+	}
+
+	socks, err := unixfd.Socketpair()
+	server_sock := socks[0]
+	client_sock := make(chan *os.File, 1)
+	client_sock <- socks[1]
+	close(client_sock)
+	defer server_sock.Close()
+	defer func() {
+		if sock, ok := <-client_sock; ok {
+			sock.Close()
+		}
+	}()
+
+	serverAgent := NewServerAgent(agentd{signer})
+	addr := unixfd.Addr(server_sock.Fd())
+	if _, err = s.Listen(addr.Network(), addr.String()); err != nil {
+		return
+	}
+	if err = s.Serve("", ipc.LeafDispatcher(serverAgent, nil)); err != nil {
+		return
+	}
+	return <-client_sock, nil
+}
+
+func (a agentd) Sign(_ ipc.ServerContext, message []byte) (security.Signature, error) {
+	return a.signer.Sign(message)
+}
+
+func (a agentd) PublicKey(ipc.ServerContext) (key wire.PublicKey, err error) {
+	err = key.Encode(a.signer.PublicKey())
+	return
+}
diff --git a/security/agent/server/wire.vdl b/security/agent/server/wire.vdl
new file mode 100644
index 0000000..695aad0
--- /dev/null
+++ b/security/agent/server/wire.vdl
@@ -0,0 +1,11 @@
+package server
+
+import (
+	"veyron2/security"
+	"veyron2/security/wire"
+)
+
+type Agent interface {
+	Sign(message []byte) (security.Signature, error)
+	PublicKey() (wire.PublicKey, error)
+}
diff --git a/security/agent/server/wire.vdl.go b/security/agent/server/wire.vdl.go
new file mode 100644
index 0000000..0c0517b
--- /dev/null
+++ b/security/agent/server/wire.vdl.go
@@ -0,0 +1,222 @@
+// This file was auto-generated by the veyron vdl tool.
+// Source: wire.vdl
+
+package server
+
+import (
+	"veyron2/security"
+
+	"veyron2/security/wire"
+
+	// The non-user imports are prefixed with "_gen_" to prevent collisions.
+	_gen_veyron2 "veyron2"
+	_gen_context "veyron2/context"
+	_gen_ipc "veyron2/ipc"
+	_gen_naming "veyron2/naming"
+	_gen_rt "veyron2/rt"
+	_gen_vdlutil "veyron2/vdl/vdlutil"
+	_gen_wiretype "veyron2/wiretype"
+)
+
+// Agent is the interface the client binds and uses.
+// Agent_ExcludingUniversal is the interface without internal framework-added methods
+// to enable embedding without method collisions.  Not to be used directly by clients.
+type Agent_ExcludingUniversal interface {
+	Sign(ctx _gen_context.T, message []byte, opts ..._gen_ipc.CallOpt) (reply security.Signature, err error)
+	PublicKey(ctx _gen_context.T, opts ..._gen_ipc.CallOpt) (reply wire.PublicKey, err error)
+}
+type Agent interface {
+	_gen_ipc.UniversalServiceMethods
+	Agent_ExcludingUniversal
+}
+
+// AgentService is the interface the server implements.
+type AgentService interface {
+	Sign(context _gen_ipc.ServerContext, message []byte) (reply security.Signature, err error)
+	PublicKey(context _gen_ipc.ServerContext) (reply wire.PublicKey, err error)
+}
+
+// BindAgent returns the client stub implementing the Agent
+// interface.
+//
+// If no _gen_ipc.Client is specified, the default _gen_ipc.Client in the
+// global Runtime is used.
+func BindAgent(name string, opts ..._gen_ipc.BindOpt) (Agent, error) {
+	var client _gen_ipc.Client
+	switch len(opts) {
+	case 0:
+		client = _gen_rt.R().Client()
+	case 1:
+		switch o := opts[0].(type) {
+		case _gen_veyron2.Runtime:
+			client = o.Client()
+		case _gen_ipc.Client:
+			client = o
+		default:
+			return nil, _gen_vdlutil.ErrUnrecognizedOption
+		}
+	default:
+		return nil, _gen_vdlutil.ErrTooManyOptionsToBind
+	}
+	stub := &clientStubAgent{client: client, name: name}
+
+	return stub, nil
+}
+
+// NewServerAgent creates a new server stub.
+//
+// It takes a regular server implementing the AgentService
+// interface, and returns a new server stub.
+func NewServerAgent(server AgentService) interface{} {
+	return &ServerStubAgent{
+		service: server,
+	}
+}
+
+// clientStubAgent implements Agent.
+type clientStubAgent struct {
+	client _gen_ipc.Client
+	name   string
+}
+
+func (__gen_c *clientStubAgent) Sign(ctx _gen_context.T, message []byte, opts ..._gen_ipc.CallOpt) (reply security.Signature, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Sign", []interface{}{message}, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubAgent) PublicKey(ctx _gen_context.T, opts ..._gen_ipc.CallOpt) (reply wire.PublicKey, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "PublicKey", nil, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubAgent) UnresolveStep(ctx _gen_context.T, opts ..._gen_ipc.CallOpt) (reply []string, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "UnresolveStep", nil, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubAgent) Signature(ctx _gen_context.T, opts ..._gen_ipc.CallOpt) (reply _gen_ipc.ServiceSignature, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Signature", nil, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubAgent) GetMethodTags(ctx _gen_context.T, method string, opts ..._gen_ipc.CallOpt) (reply []interface{}, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "GetMethodTags", []interface{}{method}, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+// ServerStubAgent wraps a server that implements
+// AgentService and provides an object that satisfies
+// the requirements of veyron2/ipc.ReflectInvoker.
+type ServerStubAgent struct {
+	service AgentService
+}
+
+func (__gen_s *ServerStubAgent) GetMethodTags(call _gen_ipc.ServerCall, method string) ([]interface{}, error) {
+	// TODO(bprosnitz) GetMethodTags() will be replaces with Signature().
+	// Note: This exhibits some weird behavior like returning a nil error if the method isn't found.
+	// This will change when it is replaced with Signature().
+	switch method {
+	case "Sign":
+		return []interface{}{}, nil
+	case "PublicKey":
+		return []interface{}{}, nil
+	default:
+		return nil, nil
+	}
+}
+
+func (__gen_s *ServerStubAgent) Signature(call _gen_ipc.ServerCall) (_gen_ipc.ServiceSignature, error) {
+	result := _gen_ipc.ServiceSignature{Methods: make(map[string]_gen_ipc.MethodSignature)}
+	result.Methods["PublicKey"] = _gen_ipc.MethodSignature{
+		InArgs: []_gen_ipc.MethodArgument{},
+		OutArgs: []_gen_ipc.MethodArgument{
+			{Name: "", Type: 71},
+			{Name: "", Type: 69},
+		},
+	}
+	result.Methods["Sign"] = _gen_ipc.MethodSignature{
+		InArgs: []_gen_ipc.MethodArgument{
+			{Name: "message", Type: 66},
+		},
+		OutArgs: []_gen_ipc.MethodArgument{
+			{Name: "", Type: 68},
+			{Name: "", Type: 69},
+		},
+	}
+
+	result.TypeDefs = []_gen_vdlutil.Any{
+		_gen_wiretype.NamedPrimitiveType{Type: 0x32, Name: "byte", Tags: []string(nil)}, _gen_wiretype.SliceType{Elem: 0x41, Name: "", Tags: []string(nil)}, _gen_wiretype.NamedPrimitiveType{Type: 0x3, Name: "veyron2/security.Hash", Tags: []string(nil)}, _gen_wiretype.StructType{
+			[]_gen_wiretype.FieldType{
+				_gen_wiretype.FieldType{Type: 0x43, Name: "Hash"},
+				_gen_wiretype.FieldType{Type: 0x42, Name: "R"},
+				_gen_wiretype.FieldType{Type: 0x42, Name: "S"},
+			},
+			"veyron2/security.Signature", []string(nil)},
+		_gen_wiretype.NamedPrimitiveType{Type: 0x1, Name: "error", Tags: []string(nil)}, _gen_wiretype.NamedPrimitiveType{Type: 0x32, Name: "veyron2/security/wire.KeyCurve", Tags: []string(nil)}, _gen_wiretype.StructType{
+			[]_gen_wiretype.FieldType{
+				_gen_wiretype.FieldType{Type: 0x46, Name: "Curve"},
+				_gen_wiretype.FieldType{Type: 0x42, Name: "XY"},
+			},
+			"veyron2/security/wire.PublicKey", []string(nil)},
+	}
+
+	return result, nil
+}
+
+func (__gen_s *ServerStubAgent) UnresolveStep(call _gen_ipc.ServerCall) (reply []string, err error) {
+	if unresolver, ok := __gen_s.service.(_gen_ipc.Unresolver); ok {
+		return unresolver.UnresolveStep(call)
+	}
+	if call.Server() == nil {
+		return
+	}
+	var published []string
+	if published, err = call.Server().Published(); err != nil || published == nil {
+		return
+	}
+	reply = make([]string, len(published))
+	for i, p := range published {
+		reply[i] = _gen_naming.Join(p, call.Name())
+	}
+	return
+}
+
+func (__gen_s *ServerStubAgent) Sign(call _gen_ipc.ServerCall, message []byte) (reply security.Signature, err error) {
+	reply, err = __gen_s.service.Sign(call, message)
+	return
+}
+
+func (__gen_s *ServerStubAgent) PublicKey(call _gen_ipc.ServerCall) (reply wire.PublicKey, err error) {
+	reply, err = __gen_s.service.PublicKey(call)
+	return
+}
diff --git a/security/agent/test.sh b/security/agent/test.sh
new file mode 100755
index 0000000..c932314
--- /dev/null
+++ b/security/agent/test.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Test running an application using the agent.
+
+source "${VEYRON_ROOT}/environment/scripts/lib/shell_test.sh"
+
+build() {
+  local GO="${REPO_ROOT}/scripts/build/go"
+  "${GO}" build veyron/security/agent/agentd || shell_test::fail "line ${LINENO}: failed to build agentd"
+  "${GO}" build -o pingpong veyron/security/agent/test || shell_test::fail "line ${LINENO}: failed to build pingpong"
+}
+
+main() {
+  local workdir="$(shell::tmp_dir)"
+  cd "${workdir}"
+  build
+
+  shell_test::setup_server_test
+  shell_test::start_server ./pingpong --server
+  export VEYRON_PUBLICID_STORE="$(shell::tmp_dir)"
+  echo VEYRON_PUBLICID_STORE=$VEYRON_PUBLICID_STORE
+  ls $VEYRON_PUBLICID_STORE
+  ./agentd --v=4 ./pingpong || shell_test::fail "line ${LINENO}: ping"
+  local identity=$(./agentd bash -c 'echo $VEYRON_IDENTITY')
+  if [[ -n "${identity}" ]]; then
+      shel_test::fail "line ${LINENO}: identity preserved"
+  fi
+
+  shell_test::pass
+}
+
+main "$@"
diff --git a/security/agent/test/main.go b/security/agent/test/main.go
new file mode 100644
index 0000000..0d554fe
--- /dev/null
+++ b/security/agent/test/main.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+
+	"veyron/lib/signals"
+	sflag "veyron/security/flag"
+	"veyron2/ipc"
+	"veyron2/rt"
+)
+
+var runServer = flag.Bool("server", false, "Whether to run in server mode")
+
+type pongd struct{}
+
+func (f *pongd) Ping(_ ipc.ServerContext, message string) (result string, err error) {
+	return "pong", nil
+}
+
+func clientMain() {
+	runtime := rt.Init()
+	log := runtime.Logger()
+	log.Info("Pinging...")
+
+	s, err := BindPingPong("pingpong")
+	if err != nil {
+		log.Fatal("error binding to server: ", err)
+	}
+
+	pong, err := s.Ping(runtime.NewContext(), "ping")
+	if err != nil {
+		log.Fatal("error pinging: ", err)
+	}
+	fmt.Println(pong)
+}
+
+func serverMain() {
+	r := rt.Init()
+	log := r.Logger()
+	s, err := r.NewServer()
+	if err != nil {
+		log.Fatal("failure creating server: ", err)
+	}
+	log.Info("Waiting for ping")
+
+	serverPong := NewServerPingPong(&pongd{})
+
+	if endpoint, err := s.Listen("tcp", "127.0.0.1:0"); err == nil {
+		fmt.Printf("Listening at: %v\n", endpoint)
+	} else {
+		log.Fatal("error listening to service: ", err)
+	}
+
+	if err := s.Serve("pingpong", ipc.LeafDispatcher(serverPong, sflag.NewAuthorizerOrDie())); err != nil {
+		log.Fatal("error serving service: ", err)
+	}
+
+	// Wait forever.
+	<-signals.ShutdownOnSignals()
+}
+
+func main() {
+	flag.Parse()
+	if *runServer {
+		serverMain()
+	} else {
+		clientMain()
+	}
+}
diff --git a/security/agent/test/wire.vdl b/security/agent/test/wire.vdl
new file mode 100644
index 0000000..0fc2ed4
--- /dev/null
+++ b/security/agent/test/wire.vdl
@@ -0,0 +1,6 @@
+package main
+
+// Simple service used in the agent tests.
+type PingPong interface {
+	Ping(message string) (string, error)
+}
diff --git a/security/agent/test/wire.vdl.go b/security/agent/test/wire.vdl.go
new file mode 100644
index 0000000..cd401c7
--- /dev/null
+++ b/security/agent/test/wire.vdl.go
@@ -0,0 +1,178 @@
+// This file was auto-generated by the veyron vdl tool.
+// Source: wire.vdl
+
+package main
+
+import (
+	// The non-user imports are prefixed with "_gen_" to prevent collisions.
+	_gen_veyron2 "veyron2"
+	_gen_context "veyron2/context"
+	_gen_ipc "veyron2/ipc"
+	_gen_naming "veyron2/naming"
+	_gen_rt "veyron2/rt"
+	_gen_vdlutil "veyron2/vdl/vdlutil"
+	_gen_wiretype "veyron2/wiretype"
+)
+
+// PingPong is the interface the client binds and uses.
+// PingPong_ExcludingUniversal is the interface without internal framework-added methods
+// to enable embedding without method collisions.  Not to be used directly by clients.
+type PingPong_ExcludingUniversal interface {
+	Ping(ctx _gen_context.T, message string, opts ..._gen_ipc.CallOpt) (reply string, err error)
+}
+type PingPong interface {
+	_gen_ipc.UniversalServiceMethods
+	PingPong_ExcludingUniversal
+}
+
+// PingPongService is the interface the server implements.
+type PingPongService interface {
+	Ping(context _gen_ipc.ServerContext, message string) (reply string, err error)
+}
+
+// BindPingPong returns the client stub implementing the PingPong
+// interface.
+//
+// If no _gen_ipc.Client is specified, the default _gen_ipc.Client in the
+// global Runtime is used.
+func BindPingPong(name string, opts ..._gen_ipc.BindOpt) (PingPong, error) {
+	var client _gen_ipc.Client
+	switch len(opts) {
+	case 0:
+		client = _gen_rt.R().Client()
+	case 1:
+		switch o := opts[0].(type) {
+		case _gen_veyron2.Runtime:
+			client = o.Client()
+		case _gen_ipc.Client:
+			client = o
+		default:
+			return nil, _gen_vdlutil.ErrUnrecognizedOption
+		}
+	default:
+		return nil, _gen_vdlutil.ErrTooManyOptionsToBind
+	}
+	stub := &clientStubPingPong{client: client, name: name}
+
+	return stub, nil
+}
+
+// NewServerPingPong creates a new server stub.
+//
+// It takes a regular server implementing the PingPongService
+// interface, and returns a new server stub.
+func NewServerPingPong(server PingPongService) interface{} {
+	return &ServerStubPingPong{
+		service: server,
+	}
+}
+
+// clientStubPingPong implements PingPong.
+type clientStubPingPong struct {
+	client _gen_ipc.Client
+	name   string
+}
+
+func (__gen_c *clientStubPingPong) Ping(ctx _gen_context.T, message string, opts ..._gen_ipc.CallOpt) (reply string, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Ping", []interface{}{message}, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubPingPong) UnresolveStep(ctx _gen_context.T, opts ..._gen_ipc.CallOpt) (reply []string, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "UnresolveStep", nil, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubPingPong) Signature(ctx _gen_context.T, opts ..._gen_ipc.CallOpt) (reply _gen_ipc.ServiceSignature, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "Signature", nil, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+func (__gen_c *clientStubPingPong) GetMethodTags(ctx _gen_context.T, method string, opts ..._gen_ipc.CallOpt) (reply []interface{}, err error) {
+	var call _gen_ipc.Call
+	if call, err = __gen_c.client.StartCall(ctx, __gen_c.name, "GetMethodTags", []interface{}{method}, opts...); err != nil {
+		return
+	}
+	if ierr := call.Finish(&reply, &err); ierr != nil {
+		err = ierr
+	}
+	return
+}
+
+// ServerStubPingPong wraps a server that implements
+// PingPongService and provides an object that satisfies
+// the requirements of veyron2/ipc.ReflectInvoker.
+type ServerStubPingPong struct {
+	service PingPongService
+}
+
+func (__gen_s *ServerStubPingPong) GetMethodTags(call _gen_ipc.ServerCall, method string) ([]interface{}, error) {
+	// TODO(bprosnitz) GetMethodTags() will be replaces with Signature().
+	// Note: This exhibits some weird behavior like returning a nil error if the method isn't found.
+	// This will change when it is replaced with Signature().
+	switch method {
+	case "Ping":
+		return []interface{}{}, nil
+	default:
+		return nil, nil
+	}
+}
+
+func (__gen_s *ServerStubPingPong) Signature(call _gen_ipc.ServerCall) (_gen_ipc.ServiceSignature, error) {
+	result := _gen_ipc.ServiceSignature{Methods: make(map[string]_gen_ipc.MethodSignature)}
+	result.Methods["Ping"] = _gen_ipc.MethodSignature{
+		InArgs: []_gen_ipc.MethodArgument{
+			{Name: "message", Type: 3},
+		},
+		OutArgs: []_gen_ipc.MethodArgument{
+			{Name: "", Type: 3},
+			{Name: "", Type: 65},
+		},
+	}
+
+	result.TypeDefs = []_gen_vdlutil.Any{
+		_gen_wiretype.NamedPrimitiveType{Type: 0x1, Name: "error", Tags: []string(nil)}}
+
+	return result, nil
+}
+
+func (__gen_s *ServerStubPingPong) UnresolveStep(call _gen_ipc.ServerCall) (reply []string, err error) {
+	if unresolver, ok := __gen_s.service.(_gen_ipc.Unresolver); ok {
+		return unresolver.UnresolveStep(call)
+	}
+	if call.Server() == nil {
+		return
+	}
+	var published []string
+	if published, err = call.Server().Published(); err != nil || published == nil {
+		return
+	}
+	reply = make([]string, len(published))
+	for i, p := range published {
+		reply[i] = _gen_naming.Join(p, call.Name())
+	}
+	return
+}
+
+func (__gen_s *ServerStubPingPong) Ping(call _gen_ipc.ServerCall, message string) (reply string, err error) {
+	reply, err = __gen_s.service.Ping(call, message)
+	return
+}