diff --git a/experimental/demoprobe/main.go b/experimental/demoprobe/main.go
index fbee76232..822a42135 100644
--- a/experimental/demoprobe/main.go
+++ b/experimental/demoprobe/main.go
@@ -11,7 +11,6 @@ import (
 
 	"github.com/weaveworks/scope/common/xfer"
 	"github.com/weaveworks/scope/probe/appclient"
-	"github.com/weaveworks/scope/probe/docker"
 	"github.com/weaveworks/scope/probe/process"
 	"github.com/weaveworks/scope/report"
 )
@@ -79,14 +78,12 @@ func demoReport(nodeCount int) report.Report {
 	connectionCount := nodeCount * 2
 	for i := 0; i < connectionCount; i++ {
 		var (
-			c            = procPool[rand.Intn(len(procPool))]
-			src          = hosts[rand.Intn(len(hosts))]
-			dst          = hosts[rand.Intn(len(hosts))]
-			srcPort      = rand.Intn(50000) + 10000
-			srcPortID    = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
-			dstPortID    = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
-			srcAddressID = report.MakeAddressNodeID("", src)
-			dstAddressID = report.MakeAddressNodeID("", dst)
+			c         = procPool[rand.Intn(len(procPool))]
+			src       = hosts[rand.Intn(len(hosts))]
+			dst       = hosts[rand.Intn(len(hosts))]
+			srcPort   = rand.Intn(50000) + 10000
+			srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
+			dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
 		)
 
 		// Endpoint topology
@@ -101,14 +98,6 @@ func demoReport(nodeCount int) report.Report {
 			"domain":    "node-" + dst,
 		}).WithEdge(srcPortID, report.EdgeMetadata{}))
 
-		// Address topology
-		r.Address = r.Address.AddNode(srcAddressID, report.MakeNode().WithLatests(map[string]string{
-			docker.Name: src,
-		}).WithAdjacent(dstAddressID))
-		r.Address = r.Address.AddNode(srcAddressID, report.MakeNode().WithLatests(map[string]string{
-			docker.Name: dst,
-		}).WithAdjacent(srcAddressID))
-
 		// Host data
 		r.Host = r.Host.AddNode("hostX", report.MakeNodeWith(map[string]string{
 			"ts":             time.Now().UTC().Format(time.RFC3339Nano),
diff --git a/experimental/genreport/generate.go b/experimental/genreport/generate.go
index b7e3016ac..6a5bc9401 100644
--- a/experimental/genreport/generate.go
+++ b/experimental/genreport/generate.go
@@ -53,14 +53,12 @@ func DemoReport(nodeCount int) report.Report {
 	connectionCount := nodeCount * 8
 	for i := 0; i < connectionCount; i++ {
 		var (
-			c            = procPool[rand.Intn(len(procPool))]
-			src          = hosts[rand.Intn(len(hosts))]
-			dst          = hosts[rand.Intn(len(hosts))]
-			srcPort      = rand.Intn(50000) + 10000
-			srcPortID    = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
-			dstPortID    = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
-			srcAddressID = report.MakeAddressNodeID("", src)
-			dstAddressID = report.MakeAddressNodeID("", dst)
+			c         = procPool[rand.Intn(len(procPool))]
+			src       = hosts[rand.Intn(len(hosts))]
+			dst       = hosts[rand.Intn(len(hosts))]
+			srcPort   = rand.Intn(50000) + 10000
+			srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
+			dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
 		)
 
 		// Endpoint topology
@@ -75,14 +73,6 @@ func DemoReport(nodeCount int) report.Report {
 			"domain": "node-" + dst,
 		}).WithEdge(srcPortID, report.EdgeMetadata{}))
 
-		// Address topology
-		r.Address = r.Address.AddNode(srcAddressID, report.MakeNode().WithLatests(map[string]string{
-			"name": src,
-		}).WithAdjacent(dstAddressID))
-		r.Address = r.Address.AddNode(dstAddressID, report.MakeNode().WithLatests(map[string]string{
-			"name": dst,
-		}).WithAdjacent(srcAddressID))
-
 		// Host data
 		r.Host = r.Host.AddNode("hostX", report.MakeNodeWith(map[string]string{
 			"ts":             time.Now().UTC().Format(time.RFC3339Nano),
diff --git a/experimental/sniff/sniffer.go b/experimental/sniff/sniffer.go
index 70bf472c5..8e6d8ecf1 100644
--- a/experimental/sniff/sniffer.go
+++ b/experimental/sniff/sniffer.go
@@ -297,39 +297,6 @@ func (s *Sniffer) Merge(p Packet, rpt *report.Report) {
 		return result
 	}
 
-	// For sure, we can add to the address topology.
-	{
-		var (
-			srcNodeID = report.MakeAddressNodeID(s.hostID, localIP)
-			dstNodeID = report.MakeAddressNodeID(s.hostID, remoteIP)
-		)
-
-		rpt.Address = addAdjacency(rpt.Address, srcNodeID, dstNodeID)
-
-		node := rpt.Address.Nodes[srcNodeID]
-		emd, _ := node.Edges.Lookup(dstNodeID)
-		if egress {
-			if emd.EgressPacketCount == nil {
-				emd.EgressPacketCount = new(uint64)
-			}
-			*emd.EgressPacketCount++
-			if emd.EgressByteCount == nil {
-				emd.EgressByteCount = new(uint64)
-			}
-			*emd.EgressByteCount += uint64(p.Network)
-		} else {
-			if emd.IngressPacketCount == nil {
-				emd.IngressPacketCount = new(uint64)
-			}
-			*emd.IngressPacketCount++
-			if emd.IngressByteCount == nil {
-				emd.IngressByteCount = new(uint64)
-			}
-			*emd.IngressByteCount += uint64(p.Network)
-		}
-		rpt.Address.Nodes[srcNodeID] = node.WithEdge(dstNodeID, emd)
-	}
-
 	// If we have ports, we can add to the endpoint topology, too.
 	if p.SrcPort != "" && p.DstPort != "" {
 		var (
diff --git a/probe/appclient/app_client_internal_test.go b/probe/appclient/app_client_internal_test.go
index cd89e5fdd..7a99ea9cd 100644
--- a/probe/appclient/app_client_internal_test.go
+++ b/probe/appclient/app_client_internal_test.go
@@ -69,7 +69,6 @@ func TestAppClientPublish(t *testing.T) {
 	// tags, transforming empty slices into nils. So, we make DeepEqual
 	// happy by setting empty `json:"omitempty"` entries to nil
 	rpt.Endpoint.Controls = nil
-	rpt.Address.Controls = nil
 	rpt.Process.Controls = nil
 	rpt.Container.Controls = nil
 	rpt.ContainerImage.Controls = nil
diff --git a/probe/endpoint/reporter.go b/probe/endpoint/reporter.go
index 6b7e9be6f..b326d87c1 100644
--- a/probe/endpoint/reporter.go
+++ b/probe/endpoint/reporter.go
@@ -165,62 +165,38 @@ func (r *Reporter) Report() (report.Report, error) {
 }
 
 func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, extraToNode *report.Node) {
-	// Update address topology
-	{
-		var (
-			fromAddressNodeID = report.MakeAddressNodeID(r.hostID, t.fromAddr)
-			toAddressNodeID   = report.MakeAddressNodeID(r.hostID, t.toAddr)
-			fromNode          = report.MakeNodeWith(map[string]string{Addr: t.fromAddr}).WithEdge(toAddressNodeID, report.EdgeMetadata{})
-			toNode            = report.MakeNodeWith(map[string]string{Addr: t.toAddr})
-		)
-
-		// In case we have a reverse resolution for the IP, we can use it for
-		// the name...
-		if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
-			toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
-		}
-
-		if extraFromNode != nil {
-			fromNode = fromNode.Merge(*extraFromNode)
-		}
-		if extraToNode != nil {
-			toNode = toNode.Merge(*extraToNode)
-		}
-		rpt.Address = rpt.Address.AddNode(fromAddressNodeID, fromNode)
-		rpt.Address = rpt.Address.AddNode(toAddressNodeID, toNode)
-	}
-
 	// Update endpoint topology
-	if r.includeProcesses {
-		var (
-			fromEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.fromAddr, strconv.Itoa(int(t.fromPort)))
-			toEndpointNodeID   = report.MakeEndpointNodeID(r.hostID, t.toAddr, strconv.Itoa(int(t.toPort)))
-
-			fromNode = report.MakeNodeWith(map[string]string{
-				Addr: t.fromAddr,
-				Port: strconv.Itoa(int(t.fromPort)),
-			}).WithEdge(toEndpointNodeID, report.EdgeMetadata{})
-			toNode = report.MakeNodeWith(map[string]string{
-				Addr: t.toAddr,
-				Port: strconv.Itoa(int(t.toPort)),
-			})
-		)
-
-		// In case we have a reverse resolution for the IP, we can use it for
-		// the name...
-		if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
-			toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
-		}
-
-		if extraFromNode != nil {
-			fromNode = fromNode.Merge(*extraFromNode)
-		}
-		if extraToNode != nil {
-			toNode = toNode.Merge(*extraToNode)
-		}
-		rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode)
-		rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode)
+	if !r.includeProcesses {
+		return
 	}
+	var (
+		fromEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.fromAddr, strconv.Itoa(int(t.fromPort)))
+		toEndpointNodeID   = report.MakeEndpointNodeID(r.hostID, t.toAddr, strconv.Itoa(int(t.toPort)))
+
+		fromNode = report.MakeNodeWith(map[string]string{
+			Addr: t.fromAddr,
+			Port: strconv.Itoa(int(t.fromPort)),
+		}).WithEdge(toEndpointNodeID, report.EdgeMetadata{})
+		toNode = report.MakeNodeWith(map[string]string{
+			Addr: t.toAddr,
+			Port: strconv.Itoa(int(t.toPort)),
+		})
+	)
+
+	// In case we have a reverse resolution for the IP, we can use it for
+	// the name...
+	if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
+		toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
+	}
+
+	if extraFromNode != nil {
+		fromNode = fromNode.Merge(*extraFromNode)
+	}
+	if extraToNode != nil {
+		toNode = toNode.Merge(*extraToNode)
+	}
+	rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode)
+	rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode)
 }
 
 func newu64(i uint64) *uint64 {
diff --git a/probe/endpoint/reporter_test.go b/probe/endpoint/reporter_test.go
index 5d8d6de3c..09d8bdc3b 100644
--- a/probe/endpoint/reporter_test.go
+++ b/probe/endpoint/reporter_test.go
@@ -78,19 +78,6 @@ func TestSpyNoProcesses(t *testing.T) {
 	if want, have := 0, len(r.Endpoint.Nodes); want != have {
 		t.Fatalf("want %d, have %d", want, have)
 	}
-
-	var (
-		scopedLocal  = report.MakeAddressNodeID(nodeID, fixLocalAddress.String())
-		scopedRemote = report.MakeAddressNodeID(nodeID, fixRemoteAddress.String())
-	)
-
-	if want, have := 1, len(r.Address.Nodes[scopedRemote].Adjacency); want != have {
-		t.Fatalf("want %d, have %d", want, have)
-	}
-
-	if want, have := scopedLocal, r.Address.Nodes[scopedRemote].Adjacency[0]; want != have {
-		t.Fatalf("want %q, have %q", want, have)
-	}
 }
 
 func TestSpyWithProcesses(t *testing.T) {
diff --git a/probe/probe_internal_test.go b/probe/probe_internal_test.go
index cb40829d0..8b0451fad 100644
--- a/probe/probe_internal_test.go
+++ b/probe/probe_internal_test.go
@@ -15,9 +15,7 @@ import (
 func TestApply(t *testing.T) {
 	var (
 		endpointNodeID = "c"
-		addressNodeID  = "d"
 		endpointNode   = report.MakeNodeWith(map[string]string{"5": "6"})
-		addressNode    = report.MakeNodeWith(map[string]string{"7": "8"})
 	)
 
 	p := New(0, 0, nil)
@@ -25,7 +23,6 @@ func TestApply(t *testing.T) {
 
 	r := report.MakeReport()
 	r.Endpoint.AddNode(endpointNodeID, endpointNode)
-	r.Address.AddNode(addressNodeID, addressNode)
 	r = p.tag(r)
 
 	for _, tuple := range []struct {
@@ -34,7 +31,6 @@ func TestApply(t *testing.T) {
 		via  string
 	}{
 		{endpointNode.Merge(report.MakeNode().WithID("c").WithTopology(report.Endpoint)), r.Endpoint, endpointNodeID},
-		{addressNode.Merge(report.MakeNode().WithID("d").WithTopology(report.Address)), r.Address, addressNodeID},
 	} {
 		if want, have := tuple.want, tuple.from.Nodes[tuple.via]; !reflect.DeepEqual(want, have) {
 			t.Errorf("want %+v, have %+v", want, have)
@@ -84,7 +80,6 @@ func TestProbe(t *testing.T) {
 
 	// omitempty
 	want.Endpoint.Controls = nil
-	want.Address.Controls = nil
 	want.Process.Controls = nil
 	want.Container.Controls = nil
 	want.ContainerImage.Controls = nil
diff --git a/probe/topology_tagger.go b/probe/topology_tagger.go
index 764875e15..44cda37cc 100644
--- a/probe/topology_tagger.go
+++ b/probe/topology_tagger.go
@@ -18,7 +18,6 @@ func (topologyTagger) Name() string { return "Topology" }
 func (topologyTagger) Tag(r report.Report) (report.Report, error) {
 	for name, t := range map[string]*report.Topology{
 		report.Endpoint:       &(r.Endpoint),
-		report.Address:        &(r.Address),
 		report.Process:        &(r.Process),
 		report.Container:      &(r.Container),
 		report.ContainerImage: &(r.ContainerImage),
diff --git a/render/expected/expected.go b/render/expected/expected.go
index 76b763764..2b692a5ef 100644
--- a/render/expected/expected.go
+++ b/render/expected/expected.go
@@ -415,143 +415,6 @@ var (
 		render.OutgoingInternetID: theOutgoingInternetNode,
 	}).Prune()
 
-	ClientAddressID         = render.MakeAddressID(fixture.ClientHostID, fixture.ClientIP)
-	ServerAddressID         = render.MakeAddressID(fixture.ServerHostID, fixture.ServerIP)
-	unknownPseudoAddress1ID = render.MakePseudoNodeID("10.10.10.10", fixture.ServerIP)
-	unknownPseudoAddress2ID = render.MakePseudoNodeID("10.10.10.11", fixture.ServerIP)
-
-	RenderedAddresses = (render.RenderableNodes{
-		ClientAddressID: {
-			ID:         ClientAddressID,
-			LabelMajor: fixture.ClientIP,
-			LabelMinor: fixture.ClientHostID,
-			Shape:      circle,
-			Node:       report.MakeNode().WithAdjacent(ServerAddressID),
-		},
-		ServerAddressID: {
-			ID:         ServerAddressID,
-			LabelMajor: fixture.ServerIP,
-			LabelMinor: fixture.ServerHostID,
-			Shape:      circle,
-			Node:       report.MakeNode(),
-		},
-		unknownPseudoAddress1ID: {
-			ID:         unknownPseudoAddress1ID,
-			LabelMajor: "10.10.10.10",
-			Pseudo:     true,
-			Shape:      circle,
-			Node:       report.MakeNode().WithAdjacent(ServerAddressID),
-		},
-		unknownPseudoAddress2ID: {
-			ID:         unknownPseudoAddress2ID,
-			LabelMajor: "10.10.10.11",
-			Pseudo:     true,
-			Shape:      circle,
-			Node:       report.MakeNode().WithAdjacent(ServerAddressID),
-		},
-		render.IncomingInternetID: {
-			ID:           render.IncomingInternetID,
-			LabelMajor:   render.InboundMajor,
-			LabelMinor:   render.InboundMinor,
-			Pseudo:       true,
-			Shape:        cloud,
-			Node:         report.MakeNode().WithAdjacent(ServerAddressID),
-			EdgeMetadata: report.EdgeMetadata{},
-		},
-	}).Prune()
-
-	ServerHostID  = render.MakeHostID(fixture.ServerHostID)
-	ClientHostID  = render.MakeHostID(fixture.ClientHostID)
-	pseudoHostID1 = render.MakePseudoNodeID(fixture.UnknownClient1IP, fixture.ServerIP)
-	pseudoHostID2 = render.MakePseudoNodeID(fixture.UnknownClient3IP, fixture.ServerIP)
-
-	RenderedHosts = (render.RenderableNodes{
-		ClientHostID: {
-			ID:         ClientHostID,
-			LabelMajor: "client",       // before first .
-			LabelMinor: "hostname.com", // after first .
-			Rank:       "hostname.com",
-			Shape:      circle,
-			Children: render.MakeRenderableNodeSet(
-				RenderedEndpoints[Client54001EndpointID],
-				RenderedEndpoints[Client54002EndpointID],
-				RenderedProcesses[ClientProcess1ID],
-				RenderedProcesses[ClientProcess2ID],
-				RenderedContainers[ClientContainerID],
-				RenderedContainerImages[ClientContainerImageID],
-				RenderedAddresses[ClientAddressID],
-			),
-			Node: report.MakeNode().WithAdjacent(ServerHostID),
-			EdgeMetadata: report.EdgeMetadata{
-				EgressPacketCount: newu64(30),
-				EgressByteCount:   newu64(300),
-			},
-		},
-		ServerHostID: {
-			ID:         ServerHostID,
-			LabelMajor: "server",       // before first .
-			LabelMinor: "hostname.com", // after first .
-			Rank:       "hostname.com",
-			Shape:      circle,
-			Children: render.MakeRenderableNodeSet(
-				RenderedEndpoints[ServerEndpointID],
-
-				RenderedProcesses[ServerProcessID],
-				RenderedContainers[ServerContainerID],
-				RenderedContainerImages[ServerContainerImageID],
-
-				RenderedAddresses[ServerAddressID],
-
-				// See #1102
-				// RemappedEndpoints[NonContainerEndpointID],
-				// RenderedEndpoints[NonContainerPseudoEndpointID],
-				// RenderedProcesses[nonContainerProcessID],
-			),
-			Node: report.MakeNode(),
-			EdgeMetadata: report.EdgeMetadata{
-				IngressPacketCount: newu64(210),
-				IngressByteCount:   newu64(2100),
-			},
-		},
-
-		pseudoHostID1: {
-			ID:           pseudoHostID1,
-			LabelMajor:   fixture.UnknownClient1IP,
-			Pseudo:       true,
-			Shape:        circle,
-			Node:         report.MakeNode().WithAdjacent(ServerHostID),
-			EdgeMetadata: report.EdgeMetadata{},
-			Children:     render.MakeRenderableNodeSet(
-			// RenderedEndpoints[unknownPseudoNode2ID],
-			// RenderedAddresses[unknownPseudoAddress1ID],
-			),
-		},
-		pseudoHostID2: {
-			ID:           pseudoHostID2,
-			LabelMajor:   fixture.UnknownClient3IP,
-			Pseudo:       true,
-			Shape:        circle,
-			Node:         report.MakeNode().WithAdjacent(ServerHostID),
-			EdgeMetadata: report.EdgeMetadata{},
-			Children:     render.MakeRenderableNodeSet(
-			// RenderedEndpoints[unknownPseudoNode2ID],
-			// RenderedAddresses[unknownPseudoAddress2ID],
-			),
-		},
-		render.IncomingInternetID: {
-			ID:           render.IncomingInternetID,
-			LabelMajor:   render.InboundMajor,
-			LabelMinor:   render.InboundMinor,
-			Pseudo:       true,
-			Shape:        cloud,
-			Node:         report.MakeNode().WithAdjacent(ServerHostID),
-			EdgeMetadata: report.EdgeMetadata{},
-			Children:     render.MakeRenderableNodeSet(
-			// RenderedEndpoints[render.TheInternetID],
-			),
-		},
-	}).Prune()
-
 	ClientPodRenderedID = render.MakePodID("ping/pong-a")
 	ServerPodRenderedID = render.MakePodID("ping/pong-b")
 
@@ -612,6 +475,58 @@ var (
 		render.OutgoingInternetID: theOutgoingInternetNode,
 	}).Prune()
 
+	ServerHostID = render.MakeHostID(fixture.ServerHostID)
+	ClientHostID = render.MakeHostID(fixture.ClientHostID)
+
+	RenderedHosts = (render.RenderableNodes{
+		ClientHostID: {
+			ID:         ClientHostID,
+			LabelMajor: "client",       // before first .
+			LabelMinor: "hostname.com", // after first .
+			Rank:       "hostname.com",
+			Shape:      circle,
+			Children: render.MakeRenderableNodeSet(
+				RenderedEndpoints[Client54001EndpointID],
+				RenderedEndpoints[Client54002EndpointID],
+				RenderedProcesses[ClientProcess1ID],
+				RenderedProcesses[ClientProcess2ID],
+				RenderedContainers[ClientContainerID],
+				RenderedContainerImages[ClientContainerImageID],
+				//RenderedPods[ClientPodRenderedID], #1142
+			),
+			Node: report.MakeNode().WithAdjacent(ServerHostID),
+			EdgeMetadata: report.EdgeMetadata{
+				EgressPacketCount: newu64(30),
+				EgressByteCount:   newu64(300),
+			},
+		},
+		ServerHostID: {
+			ID:         ServerHostID,
+			LabelMajor: "server",       // before first .
+			LabelMinor: "hostname.com", // after first .
+			Rank:       "hostname.com",
+			Shape:      circle,
+			Children: render.MakeRenderableNodeSet(
+				RenderedEndpoints[ServerEndpointID],
+				RenderedEndpoints[NonContainerEndpointID],
+				RenderedProcesses[ServerProcessID],
+				RenderedProcesses[nonContainerProcessID],
+				RenderedContainers[ServerContainerID],
+				RenderedContainerImages[ServerContainerImageID],
+				//RenderedPods[ServerPodRenderedID], #1142
+			),
+			Node: report.MakeNode().WithAdjacent(render.OutgoingInternetID),
+			EdgeMetadata: report.EdgeMetadata{
+				IngressPacketCount: newu64(210),
+				IngressByteCount:   newu64(2100),
+			},
+		},
+		unknownPseudoNode1ID:      unknownPseudoNode1(ServerHostID),
+		unknownPseudoNode2ID:      unknownPseudoNode2(ServerHostID),
+		render.IncomingInternetID: theIncomingInternetNode(ServerHostID),
+		render.OutgoingInternetID: theOutgoingInternetNode,
+	}).Prune()
+
 	ServiceRenderedID = render.MakeServiceID("ping/pongservice")
 
 	RenderedPodServices = (render.RenderableNodes{
diff --git a/render/id.go b/render/id.go
index 03a0f693c..47e98ec9b 100644
--- a/render/id.go
+++ b/render/id.go
@@ -29,11 +29,6 @@ func MakeProcessID(hostID, pid string) string {
 	return makeID("process", hostID, pid)
 }
 
-// MakeAddressID makes an address node ID for rendered nodes.
-func MakeAddressID(hostID, addr string) string {
-	return makeID("address", hostID, addr)
-}
-
 // MakeContainerID makes a container node ID for rendered nodes.
 func MakeContainerID(containerID string) string {
 	return makeID("container", containerID)
diff --git a/render/mapping.go b/render/mapping.go
index 0ebcaf6fb..c0a2eb567 100644
--- a/render/mapping.go
+++ b/render/mapping.go
@@ -213,50 +213,6 @@ func MapServiceIdentity(m RenderableNode, _ report.Networks) RenderableNodes {
 	return RenderableNodes{id: node}
 }
 
-// MapAddressIdentity maps an address topology node to an address renderable
-// node. As it is only ever run on address topology nodes, we expect that
-// certain keys are present.
-func MapAddressIdentity(m RenderableNode, local report.Networks) RenderableNodes {
-	addr, ok := m.Latest.Lookup(endpoint.Addr)
-	if !ok {
-		return RenderableNodes{}
-	}
-
-	// Conntracked connections don't have a host id unless
-	// they were merged with a procspied connection.  Filter
-	// out those that weren't.
-	_, hasHostID := m.Latest.Lookup(report.HostNodeID)
-	_, conntracked := m.Latest.Lookup(endpoint.Conntracked)
-	if !hasHostID && conntracked {
-		return RenderableNodes{}
-	}
-
-	// Nodes without a hostid are treated as psuedo nodes
-	if !hasHostID {
-		// If the addr is not in a network local to this report, we emit an
-		// internet node
-		if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
-			return RenderableNodes{TheInternetID: theInternetNode(m)}
-		}
-
-		// Otherwise generate a pseudo node for every
-		outputID := MakePseudoNodeID(addr, "")
-		if len(m.Adjacency) > 0 {
-			_, dstAddr, _ := report.ParseAddressNodeID(m.Adjacency[0])
-			outputID = MakePseudoNodeID(addr, dstAddr)
-		}
-		return RenderableNodes{outputID: newDerivedPseudoNode(outputID, addr, m)}
-	}
-
-	var (
-		id    = MakeAddressID(report.ExtractHostID(m.Node), addr)
-		major = addr
-		minor = report.ExtractHostID(m.Node)
-	)
-
-	return RenderableNodes{id: NewRenderableNodeWith(id, major, minor, "", m)}
-}
-
 // MapHostIdentity maps a host topology node to a host renderable node. As it
 // is only ever run on host topology nodes, we expect that certain keys are
 // present.
@@ -376,6 +332,46 @@ func MapIP2Container(n RenderableNode, _ report.Networks) RenderableNodes {
 	return RenderableNodes{id: node}
 }
 
+// MapEndpoint2Pseudo makes internet of host pesudo nodes from a endpoint node.
+func MapEndpoint2Pseudo(n RenderableNode, local report.Networks) RenderableNodes {
+	var node RenderableNode
+
+	addr, ok := n.Latest.Lookup(endpoint.Addr)
+	if !ok {
+		return RenderableNodes{}
+	}
+
+	port, ok := n.Latest.Lookup(endpoint.Port)
+	if !ok {
+		return RenderableNodes{}
+	}
+
+	if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
+		// If the dstNodeAddr is not in a network local to this report, we emit an
+		// internet node
+		node = theInternetNode(n)
+
+	} else if p, err := strconv.Atoi(port); err == nil && len(n.Adjacency) > 0 && p >= 32768 && p < 65535 {
+		// We are a 'client' pseudo node if the port is in the ephemeral port range.
+		// Linux uses 32768 to 61000, IANA suggests 49152 to 65535.
+		// We only exist if there is something in our adjacency
+		// Generate a single pseudo node for every (client ip, server ip, server port)
+		_, serverIP, serverPort, _ := ParseEndpointID(n.Adjacency[0])
+		node = newDerivedPseudoNode(MakePseudoNodeID(addr, serverIP, serverPort), addr, n)
+
+	} else if port != "" {
+		// Otherwise (the server node is missing), generate a pseudo node for every (server ip, server port)
+		node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr+":"+port, n)
+
+	} else {
+		// Empty port for some reason...
+		node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr, n)
+	}
+
+	node.Children = node.Children.Add(n)
+	return RenderableNodes{node.ID: node}
+}
+
 // MapEndpoint2Process maps endpoint RenderableNodes to process
 // RenderableNodes.
 //
@@ -390,42 +386,7 @@ func MapIP2Container(n RenderableNode, _ report.Networks) RenderableNodes {
 func MapEndpoint2Process(n RenderableNode, local report.Networks) RenderableNodes {
 	// Nodes without a hostid are treated as psuedo nodes
 	if _, ok := n.Latest.Lookup(report.HostNodeID); !ok {
-		var node RenderableNode
-
-		addr, ok := n.Latest.Lookup(endpoint.Addr)
-		if !ok {
-			return RenderableNodes{}
-		}
-
-		port, ok := n.Latest.Lookup(endpoint.Port)
-		if !ok {
-			return RenderableNodes{}
-		}
-
-		if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
-			// If the dstNodeAddr is not in a network local to this report, we emit an
-			// internet node
-			node = theInternetNode(n)
-
-		} else if p, err := strconv.Atoi(port); err == nil && len(n.Adjacency) > 0 && p >= 32768 && p < 65535 {
-			// We are a 'client' pseudo node if the port is in the ephemeral port range.
-			// Linux uses 32768 to 61000, IANA suggests 49152 to 65535.
-			// We only exist if there is something in our adjacency
-			// Generate a single pseudo node for every (client ip, server ip, server port)
-			_, serverIP, serverPort, _ := ParseEndpointID(n.Adjacency[0])
-			node = newDerivedPseudoNode(MakePseudoNodeID(addr, serverIP, serverPort), addr, n)
-
-		} else if port != "" {
-			// Otherwise (the server node is missing), generate a pseudo node for every (server ip, server port)
-			node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr+":"+port, n)
-
-		} else {
-			// Empty port for some reason...
-			node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr, n)
-		}
-
-		node.Children = node.Children.Add(n)
-		return RenderableNodes{node.ID: node}
+		return MapEndpoint2Pseudo(n, local)
 	}
 
 	pid, ok := n.Node.Latest.Lookup(process.PID)
@@ -625,13 +586,29 @@ func MapContainerImage2Name(n RenderableNode, _ report.Networks) RenderableNodes
 // It does not have enough info to do that, and the resulting graph
 // must be merged with a container graph to get that info.
 func MapX2Host(n RenderableNode, _ report.Networks) RenderableNodes {
-	// Propogate all pseudo nodes
+	// Don't propogate all pseudo nodes - we do this in MapEndpoint2Host
 	if n.Pseudo {
-		return RenderableNodes{n.ID: n}
+		return RenderableNodes{}
 	}
 	if _, ok := n.Node.Latest.Lookup(report.HostNodeID); !ok {
 		return RenderableNodes{}
 	}
+	id := MakeHostID(report.ExtractHostID(n.Node))
+	result := NewDerivedNode(id, n.WithParents(report.EmptySets))
+	result.Children = result.Children.Add(n)
+	result.Shape = Circle
+	result.EdgeMetadata = report.EdgeMetadata{} // Don't double count edge metadata
+	return RenderableNodes{id: result}
+}
+
+// MapEndpoint2Host takes nodes from the endpoint topology and produces
+// host nodes or pseudo nodes.
+func MapEndpoint2Host(n RenderableNode, local report.Networks) RenderableNodes {
+	// Nodes without a hostid are treated as psuedo nodes
+	if _, ok := n.Latest.Lookup(report.HostNodeID); !ok {
+		return MapEndpoint2Pseudo(n, local)
+	}
+
 	id := MakeHostID(report.ExtractHostID(n.Node))
 	result := NewDerivedNode(id, n.WithParents(report.EmptySets))
 	result.Children = result.Children.Add(n)
diff --git a/render/mapping_test.go b/render/mapping_test.go
index 40ed7cf85..88be57d8c 100644
--- a/render/mapping_test.go
+++ b/render/mapping_test.go
@@ -67,15 +67,6 @@ func TestMapContainerImageIdentity(t *testing.T) {
 	}
 }
 
-func TestMapAddressIdentity(t *testing.T) {
-	for _, input := range []testcase{
-		{"empty", nrn(report.MakeNode()), false},
-		{"basic address", nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "192.168.1.1"})), true},
-	} {
-		testMap(t, render.MapAddressIdentity, input)
-	}
-}
-
 func TestMapHostIdentity(t *testing.T) {
 	for _, input := range []testcase{
 		{"empty", nrn(report.MakeNode()), true}, // TODO it's questionable if this is actually correct
diff --git a/render/selectors.go b/render/selectors.go
index c7fe54047..a141e126c 100644
--- a/render/selectors.go
+++ b/render/selectors.go
@@ -60,11 +60,6 @@ var (
 		return MakeRenderableNodes(r.ContainerImage)
 	})
 
-	// SelectAddress selects the address topology.
-	SelectAddress = TopologySelector(func(r report.Report) RenderableNodes {
-		return MakeRenderableNodes(r.Address)
-	})
-
 	// SelectHost selects the address topology.
 	SelectHost = TopologySelector(func(r report.Report) RenderableNodes {
 		return MakeRenderableNodes(r.Host)
diff --git a/render/topologies.go b/render/topologies.go
index ffe2772f5..0603a1dc5 100644
--- a/render/topologies.go
+++ b/render/topologies.go
@@ -231,31 +231,33 @@ var ContainerHostnameRenderer = MakeMap(
 	),
 )
 
-// AddressRenderer is a Renderer which produces a renderable address
-// graph from the address topology.
-var AddressRenderer = MakeMap(
-	MapAddressIdentity,
-	SelectAddress,
-)
-
 // HostRenderer is a Renderer which produces a renderable host
-// graph from the host topology and address graph.
+// graph from the host topology.
 var HostRenderer = MakeReduce(
 	MakeMap(
-		MapX2Host,
-		FilterPseudo(ContainerImageRenderer),
+		MapEndpoint2Host,
+		EndpointRenderer,
 	),
 	MakeMap(
 		MapX2Host,
-		MakeMap(
-			MapPodIdentity,
-			SelectPod,
-		),
+		ColorConnected(ProcessRenderer),
 	),
 	MakeMap(
 		MapX2Host,
-		AddressRenderer,
+		ContainerRenderer,
 	),
+	MakeMap(
+		MapX2Host,
+		ContainerImageRenderer,
+	),
+	// Pods don't have a host id - #1142
+	// MakeMap(
+	// 	MapX2Host,
+	// 	MakeMap(
+	// 		MapPodIdentity,
+	// 		SelectPod,
+	// 	),
+	// ),
 	MakeMap(
 		MapHostIdentity,
 		SelectHost,
diff --git a/render/topologies_test.go b/render/topologies_test.go
index a41ec9040..379b4c1ac 100644
--- a/render/topologies_test.go
+++ b/render/topologies_test.go
@@ -87,14 +87,6 @@ func TestContainerImageRenderer(t *testing.T) {
 	}
 }
 
-func TestAddressRenderer(t *testing.T) {
-	have := render.AddressRenderer.Render(fixture.Report).Prune()
-	want := expected.RenderedAddresses
-	if !reflect.DeepEqual(want, have) {
-		t.Error(test.Diff(want, have))
-	}
-}
-
 func TestHostRenderer(t *testing.T) {
 	have := render.HostRenderer.Render(fixture.Report).Prune()
 	want := expected.RenderedHosts
diff --git a/report/report.go b/report/report.go
index 5c0ad3e5b..bb298ec02 100644
--- a/report/report.go
+++ b/report/report.go
@@ -10,7 +10,6 @@ import (
 // Names of the various topologies.
 const (
 	Endpoint       = "endpoint"
-	Address        = "address"
 	Process        = "process"
 	Container      = "container"
 	Pod            = "pod"
@@ -29,11 +28,6 @@ type Report struct {
 	// be traced back to a process. Edges are present.
 	Endpoint Topology
 
-	// Address nodes are addresses (e.g. ifconfig) on each host. Certain
-	// information may be present in this topology that can't be mapped to
-	// endpoints (e.g. ICMP). Edges are present.
-	Address Topology
-
 	// Process nodes are processes on each host. Edges are not present.
 	Process Topology
 
@@ -93,7 +87,6 @@ type Report struct {
 func MakeReport() Report {
 	return Report{
 		Endpoint:       MakeTopology(),
-		Address:        MakeTopology(),
 		Process:        MakeTopology(),
 		Container:      MakeTopology(),
 		ContainerImage: MakeTopology(),
@@ -111,7 +104,6 @@ func MakeReport() Report {
 func (r Report) Copy() Report {
 	return Report{
 		Endpoint:       r.Endpoint.Copy(),
-		Address:        r.Address.Copy(),
 		Process:        r.Process.Copy(),
 		Container:      r.Container.Copy(),
 		ContainerImage: r.ContainerImage.Copy(),
@@ -130,7 +122,6 @@ func (r Report) Copy() Report {
 func (r Report) Merge(other Report) Report {
 	cp := r.Copy()
 	cp.Endpoint = r.Endpoint.Merge(other.Endpoint)
-	cp.Address = r.Address.Merge(other.Address)
 	cp.Process = r.Process.Merge(other.Process)
 	cp.Container = r.Container.Merge(other.Container)
 	cp.ContainerImage = r.ContainerImage.Merge(other.ContainerImage)
@@ -147,7 +138,6 @@ func (r Report) Merge(other Report) Report {
 func (r Report) Topologies() []Topology {
 	return []Topology{
 		r.Endpoint,
-		r.Address,
 		r.Process,
 		r.Container,
 		r.ContainerImage,
diff --git a/test/fixture/report_fixture.go b/test/fixture/report_fixture.go
index fde47d497..edcfec2ab 100644
--- a/test/fixture/report_fixture.go
+++ b/test/fixture/report_fixture.go
@@ -85,13 +85,6 @@ var (
 	ClientContainerImageName   = "image/client"
 	ServerContainerImageName   = "image/server"
 
-	ClientAddressNodeID   = report.MakeAddressNodeID(ClientHostID, ClientIP)
-	ServerAddressNodeID   = report.MakeAddressNodeID(ServerHostID, ServerIP)
-	UnknownAddress1NodeID = report.MakeAddressNodeID(ServerHostID, UnknownClient1IP)
-	UnknownAddress2NodeID = report.MakeAddressNodeID(ServerHostID, UnknownClient2IP)
-	UnknownAddress3NodeID = report.MakeAddressNodeID(ServerHostID, UnknownClient3IP)
-	RandomAddressNodeID   = report.MakeAddressNodeID(ServerHostID, RandomClientIP) // this should become an internet node
-
 	KubernetesNamespace = "ping"
 	ClientPodID         = "ping/pong-a"
 	ServerPodID         = "ping/pong-b"
@@ -315,35 +308,6 @@ var (
 				).WithID(ServerContainerImageNodeID).WithTopology(report.ContainerImage),
 			},
 		},
-		Address: report.Topology{
-			Nodes: report.Nodes{
-				ClientAddressNodeID: report.MakeNode().WithLatests(map[string]string{
-					endpoint.Addr:     ClientIP,
-					report.HostNodeID: ClientHostNodeID,
-				}).WithEdge(ServerAddressNodeID, report.EdgeMetadata{}),
-
-				ServerAddressNodeID: report.MakeNode().WithLatests(map[string]string{
-					endpoint.Addr:     ServerIP,
-					report.HostNodeID: ServerHostNodeID,
-				}),
-
-				UnknownAddress1NodeID: report.MakeNode().WithLatests(map[string]string{
-					endpoint.Addr: UnknownClient1IP,
-				}).WithAdjacent(ServerAddressNodeID),
-
-				UnknownAddress2NodeID: report.MakeNode().WithLatests(map[string]string{
-					endpoint.Addr: UnknownClient2IP,
-				}).WithAdjacent(ServerAddressNodeID),
-
-				UnknownAddress3NodeID: report.MakeNode().WithLatests(map[string]string{
-					endpoint.Addr: UnknownClient3IP,
-				}).WithAdjacent(ServerAddressNodeID),
-
-				RandomAddressNodeID: report.MakeNode().WithLatests(map[string]string{
-					endpoint.Addr: RandomClientIP,
-				}).WithAdjacent(ServerAddressNodeID),
-			},
-		},
 		Host: report.Topology{
 			Nodes: report.Nodes{
 				ClientHostNodeID: report.MakeNodeWith(map[string]string{