diff --git a/profiles/gce/init.go b/profiles/gce/init.go
index 575543d..72b2774 100644
--- a/profiles/gce/init.go
+++ b/profiles/gce/init.go
@@ -10,18 +10,22 @@
 
 	"veyron.io/veyron/veyron2"
 	"veyron.io/veyron/veyron2/config"
+	"veyron.io/veyron/veyron2/ipc"
 	"veyron.io/veyron/veyron2/rt"
 
 	"veyron.io/veyron/veyron/profiles/internal/gce"
 )
 
+var ListenSpec = &ipc.ListenSpec{
+	Protocol: "tcp",
+	Address:  "127.0.0.1:0",
+}
+
 func init() {
 	rt.RegisterProfile(&profile{})
 }
 
-type profile struct {
-	publicAddress net.Addr
-}
+type profile struct{}
 
 func (p *profile) Name() string {
 	return "GCE"
@@ -40,12 +44,6 @@
 	return "net " + p.Platform().String()
 }
 
-func (p *profile) AddressChooser() veyron2.AddressChooser {
-	return func(network string, addrs []net.Addr) (net.Addr, error) {
-		return p.publicAddress, nil
-	}
-}
-
 func (p *profile) Init(rt veyron2.Runtime, publisher *config.Publisher) {
 	if !gce.RunningOnGCE() {
 		return
@@ -57,6 +55,8 @@
 		// TODO(cnicolaou): add error return to init
 		//		return err
 	} else {
-		p.publicAddress = &net.IPAddr{IP: ip}
+		ListenSpec.AddressChooser = func(network string, addrs []net.Addr) (net.Addr, error) {
+			return &net.IPAddr{IP: ip}, nil
+		}
 	}
 }
diff --git a/profiles/generic.go b/profiles/generic.go
index 223cd0d..03ef607 100644
--- a/profiles/generic.go
+++ b/profiles/generic.go
@@ -3,10 +3,17 @@
 import (
 	"veyron.io/veyron/veyron2"
 	"veyron.io/veyron/veyron2/config"
+	"veyron.io/veyron/veyron2/ipc"
 
 	"veyron.io/veyron/veyron/profiles/internal"
 )
 
+var ListenSpec = &ipc.ListenSpec{
+	Protocol:       "tcp",
+	Address:        "127.0.0.1:0",
+	AddressChooser: internal.IPAddressChooser,
+}
+
 type generic struct{}
 
 // New returns a new instance of a very generic Profile. It can be used
@@ -28,10 +35,6 @@
 	return p
 }
 
-func (*generic) AddressChooser() veyron2.AddressChooser {
-	return internal.IPAddressChooser
-}
-
 func (g *generic) Init(rt veyron2.Runtime, _ *config.Publisher) {
 	rt.Logger().VI(1).Infof("%s", g)
 }
diff --git a/profiles/roaming/init.go b/profiles/roaming/init.go
index 156065c..d5221f0 100644
--- a/profiles/roaming/init.go
+++ b/profiles/roaming/init.go
@@ -51,8 +51,7 @@
 }
 
 type profile struct {
-	addrChooser veyron2.AddressChooser
-	gce         string
+	gce string
 }
 
 func preferredIPAddress(network string, addrs []net.Addr) (net.Addr, error) {
@@ -70,7 +69,7 @@
 }
 
 func New() veyron2.Profile {
-	return &profile{addrChooser: preferredIPAddress}
+	return &profile{}
 }
 
 func (p *profile) Platform() *veyron2.Platform {
@@ -114,7 +113,7 @@
 	// if we are indeed running on GCE.
 	if !public {
 		if addr := handleGCE(rt, publisher); addr != nil {
-			p.addrChooser = func(string, []net.Addr) (net.Addr, error) {
+			ListenSpec.AddressChooser = func(string, []net.Addr) (net.Addr, error) {
 				return addr, nil
 			}
 			p.gce = "+gce"
@@ -132,18 +131,17 @@
 	}
 
 	protocol := listenProtocolFlag.Protocol
+	ListenSpec.StreamPublisher = publisher
+	ListenSpec.StreamName = "dhcp"
+	ListenSpec.AddressChooser = preferredIPAddress
 	log.VI(2).Infof("Initial Network Settings: %s %s available: %s", protocol, listenAddressFlag, state)
-	go monitorNetworkSettings(rt, stop, ch, state, protocol, p.addrChooser)
-}
-
-func (p *profile) AddressChooser() veyron2.AddressChooser {
-	return p.addrChooser
+	go monitorNetworkSettings(rt, stop, ch, state, ListenSpec)
 }
 
 // monitorNetworkSettings will monitor network configuration changes and
 // publish subsequent Settings to reflect any changes detected.
 func monitorNetworkSettings(rt veyron2.Runtime, stop <-chan struct{},
-	ch chan<- config.Setting, prev netstate.AddrList, protocol string, chooser veyron2.AddressChooser) {
+	ch chan<- config.Setting, prev netstate.AddrList, listenSpec *ipc.ListenSpec) {
 	defer close(ch)
 
 	log := rt.Logger()
@@ -180,7 +178,7 @@
 				ch <- ipc.NewRmAddrsSetting(removed)
 			}
 			// We will always send the best currently available address
-			if chosen, err := chooser(protocol, cur); err == nil && chosen != nil {
+			if chosen, err := listenSpec.AddressChooser(listenSpec.Protocol, cur); err == nil && chosen != nil {
 				ch <- ipc.NewAddAddrsSetting([]net.Addr{chosen})
 			}
 			prev = cur
diff --git a/profiles/roaming/net_watcher.go b/profiles/roaming/net_watcher.go
index 1c71022..074c6e5 100644
--- a/profiles/roaming/net_watcher.go
+++ b/profiles/roaming/net_watcher.go
@@ -17,8 +17,8 @@
 
 	fmt.Println("Profile: ", r.Profile().Name())
 
-	if addrOpt := r.Profile().PreferredAddressOpt(); addrOpt != nil {
-		if gce, err := addrOpt("", nil); err == nil {
+	if chooser := roaming.ListenSpec.AddressChooser; chooser != nil {
+		if gce, err := chooser("", nil); err == nil {
 			fmt.Printf("%s: 1:1 NAT address is %s\n", r.Profile().Name(), gce)
 		}
 	}
diff --git a/runtimes/google/ipc/full_test.go b/runtimes/google/ipc/full_test.go
index 2a72afe..bb9f3b6 100644
--- a/runtimes/google/ipc/full_test.go
+++ b/runtimes/google/ipc/full_test.go
@@ -4,7 +4,6 @@
 	"errors"
 	"fmt"
 	"io"
-	"net"
 	"os"
 	"reflect"
 	"strings"
@@ -1031,6 +1030,11 @@
 	}
 }
 
+/*
+ * TODO(cnicolaou): temporarily remove these until we move ListenX over
+ * to be Listen.
+ */
+/*
 func TestPreferredAddress(t *testing.T) {
 	sm := imanager.InternalNew(naming.FixedRoutingID(0x555555555))
 	defer sm.Shutdown()
@@ -1088,6 +1092,7 @@
 		t.Errorf("got %q, want %q", got, want)
 	}
 }
+*/
 
 type proxyHandle struct {
 	ns      naming.Namespace
diff --git a/runtimes/google/ipc/server.go b/runtimes/google/ipc/server.go
index 2859f63..10862d1 100644
--- a/runtimes/google/ipc/server.go
+++ b/runtimes/google/ipc/server.go
@@ -16,6 +16,8 @@
 	ivtrace "veyron.io/veyron/veyron/runtimes/google/vtrace"
 	vsecurity "veyron.io/veyron/veyron/security"
 
+	"veyron.io/veyron/veyron/profiles/internal"
+
 	"veyron.io/veyron/veyron2"
 	"veyron.io/veyron/veyron2/config"
 	"veyron.io/veyron/veyron2/context"
@@ -49,9 +51,7 @@
 	stopped          bool                              // whether the server has been stopped.
 	stoppedChan      chan struct{}                     // closed when the server has been stopped.
 	ns               naming.Namespace
-	addressChooser   veyron2.AddressChooser
 	servesMountTable bool
-	roamingOpt       veyron2.RoamingPublisherOpt
 	debugAuthorizer  security.Authorizer
 	// TODO(cnicolaou): add roaming stats to ipcStats
 	stats *ipcStats // stats for this server.
@@ -78,10 +78,6 @@
 	}
 	for _, opt := range opts {
 		switch opt := opt.(type) {
-		case *veyron2.AddressChooserOpt:
-			s.addressChooser = opt.AddressChooser
-		case *veyron2.RoamingPublisherOpt:
-			s.roamingOpt = *opt
 		case stream.ListenerOpt:
 			// Collect all ServerOpts that are also ListenerOpts.
 			s.listenerOpts = append(s.listenerOpts, opt)
@@ -170,20 +166,11 @@
 				return nil, fmt.Errorf("ipc: Listen(%q, %q) failed to parse IP address from address", protocol, address)
 			}
 			if ip.IsUnspecified() {
-				if s.addressChooser != nil {
-					// Need to find a usable IP address.
-					if addrs, err := netstate.GetAccessibleIPs(); err == nil {
-						if a, err := s.addressChooser(protocol, addrs); err == nil {
-							if ip := netstate.AsIP(a); ip != nil {
-								// a may be an IPNet or an IPAddr under the covers,
-								// but we really want the IP portion without any
-								// netmask so we use AsIP to ensure that.
-								iep.Address = net.JoinHostPort(ip.String(), port)
-							}
-						}
+				addrs, err := netstate.GetAccessibleIPs()
+				if err == nil {
+					if a, err := internal.IPAddressChooser(iep.Protocol, addrs); err == nil {
+						iep.Address = net.JoinHostPort(a.String(), port)
 					}
-				} else {
-					vlog.Errorf("no address chooser specified")
 				}
 			}
 		}
@@ -219,7 +206,7 @@
 // externalEndpoint examines the endpoint returned by the stream listen call
 // and fills in the address to publish to the mount table. It also returns the
 // IP host address that it selected for publishing to the mount table.
-func (s *server) externalEndpoint(lep naming.Endpoint) (*inaming.Endpoint, *net.IPAddr, error) {
+func (s *server) externalEndpoint(chooser ipc.AddressChooser, lep naming.Endpoint) (*inaming.Endpoint, *net.IPAddr, error) {
 	// We know the endpoint format, so we crack it open...
 	iep, ok := lep.(*inaming.Endpoint)
 	if !ok {
@@ -236,12 +223,12 @@
 		if ip == nil {
 			return nil, nil, fmt.Errorf("failed to parse %q as an IP host", host)
 		}
-		if ip.IsUnspecified() && s.addressChooser != nil {
+		if ip.IsUnspecified() && chooser != nil {
 			// Need to find a usable IP address since the call to listen
 			// didn't specify one.
 			addrs, err := netstate.GetAccessibleIPs()
 			if err == nil {
-				if a, err := s.addressChooser(iep.Protocol, addrs); err == nil {
+				if a, err := chooser(iep.Protocol, addrs); err == nil {
 					iep.Address = net.JoinHostPort(a.String(), port)
 					return iep, a.(*net.IPAddr), nil
 				}
@@ -281,7 +268,7 @@
 		vlog.Errorf("ipc: Listen on %v %v failed: %v", protocol, address, err)
 		return nil, err
 	}
-	ep, ipaddr, err := s.externalEndpoint(lep)
+	ep, ipaddr, err := s.externalEndpoint(listenSpec.AddressChooser, lep)
 	if ipaddr == nil || err != nil {
 		ln.Close()
 		if ipaddr == nil {
@@ -299,10 +286,9 @@
 	}
 
 	h, _, _ := net.SplitHostPort(address)
-	if ip := net.ParseIP(h); ip != nil && ip.IsLoopback() {
-		publisher := s.roamingOpt.Publisher
-		streamName := s.roamingOpt.StreamName
-
+	publisher := listenSpec.StreamPublisher
+	if ip := net.ParseIP(h); ip != nil && ip.IsLoopback() && publisher != nil {
+		streamName := listenSpec.StreamName
 		ch := make(chan config.Setting)
 		_, err := publisher.ForkStream(streamName, ch)
 		if err != nil {
diff --git a/runtimes/google/rt/ipc.go b/runtimes/google/rt/ipc.go
index 4655b01..aa46f40 100644
--- a/runtimes/google/rt/ipc.go
+++ b/runtimes/google/rt/ipc.go
@@ -138,28 +138,18 @@
 	ns := rt.ns
 	var id security.PublicID
 	var otherOpts []ipc.ServerOpt
-	addressChooserOpt := &veyron2.AddressChooserOpt{rt.profile.AddressChooser()}
-	roamingOpt := &veyron2.RoamingPublisherOpt{rt.publisher, "roaming"}
 	for _, opt := range opts {
 		switch topt := opt.(type) {
 		case veyron2.NamespaceOpt:
 			ns = topt
 		case veyron2.LocalIDOpt:
 			id = topt.PublicID
-		case *veyron2.AddressChooserOpt:
-			addressChooserOpt = topt
-		case *veyron2.RoamingPublisherOpt:
-			roamingOpt = topt
 		default:
 			otherOpts = append(otherOpts, opt)
 		}
 	}
 	// Add the option that provides the local identity to the server.
 	otherOpts = append(otherOpts, rt.newLocalID(id))
-	// Add the preferredAddr and roaming opts
-	otherOpts = append(otherOpts, addressChooserOpt)
-	otherOpts = append(otherOpts, roamingOpt)
-
 	ctx := rt.NewContext()
 
 	return iipc.InternalNewServer(ctx, sm, ns, otherOpts...)