diff --git a/xos/configurations/cord-pod/README.md b/xos/configurations/cord-pod/README.md
index c6511f7..6bec6d8 100644
--- a/xos/configurations/cord-pod/README.md
+++ b/xos/configurations/cord-pod/README.md
@@ -19,19 +19,20 @@
 
 ## How to bring up CORD
 
-Installing a CORD POD requires three steps:
- 1. Installing OpenStack on a cluster
- 2. Setting up the ONOS VTN app and configuring OVS on the nova-compute nodes to be
+Installing a CORD POD involves these steps:
+ 1. Install OpenStack on a cluster
+ 2. Set up the ONOS VTN app and configuring OVS on the nova-compute nodes to be
     controlled by VTN
- 3. Bringing up XOS with the CORD services
+ 3. Set up external connectivity for VMs (if not using the CORD fabric)
+ 4. Bring up XOS with the CORD services
 
-### Installing OpenStack
+### Install OpenStack
 
 Follow the instructions in the [README.md](https://github.com/open-cloud/openstack-cluster-setup/blob/master/README.md)
 file of the [open-cloud/openstack-cluster-setup](https://github.com/open-cloud/openstack-cluster-setup/)
 repository.
 
-### Setting up ONOS VTN
+### Set up ONOS VTN
 
 The OpenStack installer above creates a VM called *onos-cord* on the head node.
 To bring up ONOS in this VM, log into the head node and run:
@@ -40,18 +41,17 @@
 ubuntu@onos-cord:~$ cd cord; sudo docker-compose up -d
 ```
 
-Currently it's also necessary to do some manual configuration on each compute
-node.  As root do the following:
- 1. Disable neutron-plugin-openvswitch-agent, if running:
-```
-$ service neutron-plugin-openvswitch-agent stop
-$ echo manual > /etc/init/neutron-plugin-openvswitch-agent.override
-```
- 2. Delete *br-int* and all other bridges from OVS
- 3. Configure OVS to listen for connections from VTN:
-```
-$ ovs-appctl -t ovsdb-server ovsdb-server/add-remote ptcp:6641
-```
+### Set up external connectivity for VMs
+
+The CORD fabric is responsible for providing external (Internet) connectivity
+for VMs created on CORD.  If you are running on CloudLab (or another development
+environment) and want external connectivity without the fabric, download [this script](https://raw.githubusercontent.com/open-cloud/openstack-cluster-setup/master/scripts/compute-ext-net.sh)
+ and run it as root:
+ ```
+ $ sudo compute-ext-net.sh
+ ```
+
+Setting up the full fabric is beyond the scope of this README.
 
 ### Bringing up XOS
 
@@ -62,13 +62,30 @@
 ubuntu@xos:~$ cd xos/xos/configurations/cord-pod
 ```
 
-Next, put the following files in this directory:
+Next, check that the following files exist in this directory:
 
  * *admin-openrc.sh*: Admin credentials for your OpenStack cloud
  * *id_rsa[.pub]*: A keypair that will be used by the various services
  * *node_key*: A private key that allows root login to the compute nodes
 
-Then XOS can be brought up for CORD by running a few 'make' commands:
+They will have been put there for you by the cluster installation scripts.
+
+If your setup uses the CORD fabric, you need to edit `make-vtn-networkconfig-json.sh`
+and `cord-vtn-vsg.yml` as appropriate.  Specifically, in
+`make-vtn-networkconfig-json.sh` you need to set these parameters for VTN:
+ * gatewayIp
+ * gatewayMac
+ * PHYPORT
+
+And in `cord-vtn-vsg.yml`:
+ * public_addresses -> properties -> addresses
+ * service_vsg -> properties -> wan_container_gateway_ip
+ * service_vsg -> properties -> wan_container_gateway_mac
+ * service_vsg -> properties -> wan_container_netbits
+
+If you're not using the fabric then the default values should be OK.  
+
+XOS can then be brought up for CORD by running a few 'make' commands:
 ```
 ubuntu@xos:~/xos/xos/configurations/cord-pod$ make
 ubuntu@xos:~/xos/xos/configurations/cord-pod$ make vtn
