diff --git a/roles/head-prep/tasks/main.yml b/roles/head-prep/tasks/main.yml
index c17ecbe..a858ce3 100644
--- a/roles/head-prep/tasks/main.yml
+++ b/roles/head-prep/tasks/main.yml
@@ -33,6 +33,7 @@
     - python-neutronclient
     - python-keystoneclient
     - python-glanceclient
+    - python-lxml
     - virt-top
 
 - name: Prep user account by adding to libvirtd group and generating SSH key
diff --git a/roles/onos-load-apps/defaults/main.yml b/roles/onos-load-apps/defaults/main.yml
new file mode 100644
index 0000000..2dd2a2e
--- /dev/null
+++ b/roles/onos-load-apps/defaults/main.yml
@@ -0,0 +1,16 @@
+---
+# onos-load-apps/defaults/main.yml
+
+onos_cord_vm_hostname: "onos-cord-1"
+onos_web_user: "onos"
+onos_web_pass: "rocks"
+
+cord_apps:
+  - name: cord-config
+    onos_name: org.opencord.config
+  - name: vtn
+    onos_name: org.opencord.vtn
+
+cord_apps_repo_url: "https://oss.sonatype.org/content/repositories/public"
+cord_apps_version: "latest"
+
diff --git a/roles/onos-load-apps/files/config.xml b/roles/onos-load-apps/files/config.xml
deleted file mode 100644
index 58aad2a..0000000
--- a/roles/onos-load-apps/files/config.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<app name="org.opencord.config" origin="ON.Lab" version="1.0-SNAPSHOT" 
-        category="Configuration" url="http://opencord.org" title="CORD Configuration" 
-        featuresRepo="mvn:org.opencord/config/1.0-SNAPSHOT/xml/features" 
-        features="cord-config"> 
-    <description>CORD Configuration</description> 
-    <artifact>mvn:org.opencord/config/1.0-SNAPSHOT</artifact> 
-</app> 
diff --git a/roles/onos-load-apps/files/onos-app b/roles/onos-load-apps/files/onos-app
new file mode 100644
index 0000000..fb6fff6
--- /dev/null
+++ b/roles/onos-load-apps/files/onos-app
@@ -0,0 +1,80 @@
+#!/bin/bash
+# -----------------------------------------------------------------------------
+# Tool to manage ONOS applications using REST API.
+# -----------------------------------------------------------------------------
+
+node=${1:-$OCI}
+cmd=${2:-list}
+app=${3}
+
+export URL=http://$node:8181/onos/v1/applications
+export HDR="-HContent-Type:application/octet-stream"
+export HAJ="-HContent-Type:application/json"
+export curl="curl -sS --user $ONOS_WEB_USER:$ONOS_WEB_PASS"
+
+# Prints usage help
+function usage {
+    echo "usage: onos-app <node-ip> list" >&2
+    echo "       onos-app <node-ip> {install|install!} <app-file>" >&2
+    echo "       onos-app <node-ip> {reinstall|reinstall!} [<app-name>] <app-file>" >&2
+    echo "       onos-app <node-ip> {activate|deactivate|uninstall} <app-name>" >&2
+    exit 1
+}
+
+# Extract app name from the specified *.oar file
+function appName {
+    aux=/tmp/aux$$.jar
+    cp $1 $aux
+    pushd /tmp >/dev/null
+    jar xf $aux app.xml && grep name= app.xml | cut -d\" -f2
+    rm -f $aux /tmp/app.xml
+    popd >/dev/null
+}
+
+[ -z $node -o "$node" = "-h" -o "$node" = "--help" -o "$node" = "-?" ] && usage
+
+case $cmd in
+    list) $curl -X GET $URL;;
+    installUrl!|installUrl)
+        activate="false"
+        [ $cmd = "installUrl!" ] && activate="true"
+        [ $# -lt 3 ] && usage
+        appurl=$3
+        $curl -X POST $HAJ -d '{"url" : "'"$appurl"'", "activate" : "'$activate'" }' $URL
+        ;;
+    install!|install)
+        [ $cmd = "install!" ] && activate="?activate=true"
+        [ $# -lt 3 -o ! -f $app ] && usage
+        $curl -X POST $HDR $URL$activate --data-binary @$app
+        ;;
+
+    reinstall!|reinstall)
+        [ $cmd = "reinstall!" ] && activate="?activate=true"
+        [ $# -lt 4 -a ! -f "$3" ] && usage
+        [ $# -eq 4 -a ! -f "$4" ] && usage
+        oar=$4
+        [ $# -lt 4 ] && oar=$3 && app=$(appName $oar)
+        $curl -X DELETE $URL/$app
+        $curl -X POST $HDR $URL$activate --data-binary @$oar
+        ;;
+
+    uninstall)
+        [ $# -lt 3 ] && usage
+        $curl -X DELETE $URL/$app
+        ;;
+    activate)
+        [ $# -lt 3 ] && usage
+        $curl -X POST $URL/$app/active
+        ;;
+    deactivate)
+        [ $# -lt 3 ] && usage
+        $curl -X DELETE $URL/$app/active
+        ;;
+
+    *) usage;;
+esac
+
+
+status=$?
+echo # new line for prompt
+exit $status
diff --git a/roles/onos-load-apps/files/vtn.xml b/roles/onos-load-apps/files/vtn.xml
deleted file mode 100644
index 9b3eae7..0000000
--- a/roles/onos-load-apps/files/vtn.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<app name="org.opencord.vtn" origin="ON.Lab" version="1.0-SNAPSHOT" 
-        category="Traffic Steering" url="http://onosproject.org" title="CORD Virtual Tenant Network" 
-        featuresRepo="mvn:org.opencord/vtn/1.0-SNAPSHOT/xml/features" 
-        features="cord-vtn" 
-        apps="org.onosproject.ovsdb-base,org.onosproject.dhcp,org.onosproject.xosclient,org.opencord.config"> 
-    <description>VTN for CORD</description> 
-    <artifact>mvn:org.opencord/vtn/1.0-SNAPSHOT</artifact> 
-</app> 
diff --git a/roles/onos-load-apps/tasks/main.yml b/roles/onos-load-apps/tasks/main.yml
index e4f165a..32a8a21 100644
--- a/roles/onos-load-apps/tasks/main.yml
+++ b/roles/onos-load-apps/tasks/main.yml
@@ -1,18 +1,46 @@
 ---
 # onos-load-apps/tasks/main.yml
-#
-# Install CORD ONOS apps from local containers
 
-- name: Disable loading from Maven repo
+- name: Disable loading of CORD apps from Maven repo
   command: ansible xos-1 -u ubuntu -m lineinfile \
     -a "dest=~/service-profile/{{ xos_configuration }}/make-vtn-external-yaml.sh state=absent regexp='install_dependencies'"
 
-- name: Load the apps using Docker
-  command: ansible xos-1 -u ubuntu -m shell \
-    -a "cd ~/xos/containers/cord-apps; make {{ item }}; sudo docker run xosproject/cord-app-{{ item }}"
+- name: Create directory for CORD apps and load script
+  file:
+    state: directory
+    dest: "{{ ansible_user_dir }}/cord_apps/"
+
+- name: Create cord_app_loader.sh script to load CORD apps
+  template:
+    src: "{{ item }}.j2"
+    dest: "{{ ansible_user_dir }}/cord_apps/{{ item }}"
+    mode: 0755
+  with_items:
+    - cord_app_loader.sh
+
+- name: Copy onos-app REST API app loader tool
+  copy:
+    src: "{{ item }}"
+    dest: "{{ ansible_user_dir }}/cord_apps/{{ item }}"
+    mode: 0755
+  with_items:
+   - onos-app
+
+- name: Download CORD apps from maven repo
+  maven_artifact:
+    repository_url: "{{ cord_apps_repo_url }}"
+    group_id: "org.opencord"
+    artifact_id: "{{ item.name }}"
+    version: "{{ cord_apps_version }}"
+    extension: "oar"
+    dest: "{{ ansible_user_dir }}/cord_apps/{{ item.name }}.oar"
   with_items: "{{ cord_apps }}"
 
-- name: Enable debugging for cord apps
-  shell: "sshpass -p 'karaf' ssh -p 8101 karaf@onos-cord-1 log:set DEBUG org.opencord.{{ item }}"
-  with_items: "{{ cord_apps }}"
+- name: Wait for ONOS to be ready
+  wait_for:
+    host: "{{ onos_cord_vm_hostname }}"
+    port: 8181
+
+- name: Install CORD apps
+  command: "{{ ansible_user_dir }}/cord_apps/cord_app_loader.sh"
 
diff --git a/roles/onos-load-apps/templates/cord_app_loader.sh.j2 b/roles/onos-load-apps/templates/cord_app_loader.sh.j2
new file mode 100644
index 0000000..742f2d3
--- /dev/null
+++ b/roles/onos-load-apps/templates/cord_app_loader.sh.j2
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+# onos-vm-install/templates/cord_loader.sh.j2
+# loads/activates .oar CORD app files into ONOS instance
+
+export ONOS_WEB_USER={{ onos_web_user }}
+export ONOS_WEB_PASS={{ onos_web_pass }}
+
+BASEDIR=$(dirname "$0") # current directory of script
+
+{% for cord_app in cord_apps %}
+${BASEDIR}/onos-app {{ onos_cord_vm_hostname }} install ${BASEDIR}/{{ cord_app.name }}.oar
+${BASEDIR}/onos-app {{ onos_cord_vm_hostname }} activate {{ cord_app.onos_name }}
+{% endfor %}
+
diff --git a/roles/onos-load-apps/vars/main.yml b/roles/onos-load-apps/vars/main.yml
deleted file mode 100644
index 8bce3aa..0000000
--- a/roles/onos-load-apps/vars/main.yml
+++ /dev/null
@@ -1,5 +0,0 @@
----
-
-cord_apps:
-- config
-- vtn
diff --git a/roles/onos-vm-install/defaults/main.yml b/roles/onos-vm-install/defaults/main.yml
index 2a5be99..68d97bb 100644
--- a/roles/onos-vm-install/defaults/main.yml
+++ b/roles/onos-vm-install/defaults/main.yml
@@ -1,2 +1,8 @@
---- 
+---
+# onos-vm-install/defaults/main.yml
+
+trust_store_pw: 222222
+
+onos_docker_image: "onosproject/onos:1.6"
+
 
diff --git a/roles/onos-vm-install/files/Dockerfile.xos-onos b/roles/onos-vm-install/files/Dockerfile.xos-onos
deleted file mode 100644
index 6ac780b..0000000
--- a/roles/onos-vm-install/files/Dockerfile.xos-onos
+++ /dev/null
@@ -1,18 +0,0 @@
-# ONOS dockerfile with XOS additions
-
-#FROM xosproject/onos-fork
-FROM onosproject/onos:1.6
-MAINTAINER Zack Williams <zdw@cs.arizona.edu>
-
-# Include SSL certs
-COPY xos-certs.crt /usr/local/share/ca-certificates/xos-certs.crt
-RUN update-ca-certificates
-
-# Create Java KeyStore from certs
-RUN openssl x509 -in /usr/local/share/ca-certificates/xos-certs.crt -outform der -out /usr/local/share/ca-certificates/xos-certs.der
-RUN keytool -import -noprompt -storepass 222222 -alias xos-certs -file /usr/local/share/ca-certificates/xos-certs.der -keystore /usr/local/share/ca-certificates/xos-certs.jks
-
-# Updated onos-service to use the jks
-COPY onos-service /root/onos/bin/onos-service
-RUN chmod 755 /root/onos/bin/onos-service
-
diff --git a/roles/onos-vm-install/files/onos-setup-playbook.yml b/roles/onos-vm-install/files/onos-setup-playbook.yml
index 4ab44cb..fe33054 100644
--- a/roles/onos-vm-install/files/onos-setup-playbook.yml
+++ b/roles/onos-vm-install/files/onos-setup-playbook.yml
@@ -9,12 +9,13 @@
 
     - name: Create CORD directory
       file:
-        path={{ ansible_user_dir }}/cord
-        state=directory
+        path: "{{ ansible_user_dir }}/cord"
+        state: directory
 
+# Should replace with http://docs.ansible.com/ansible/docker_module.html, when replacements are stable
     - name: Pull docker image for ONOS
       become: yes
-      command: docker pull onosproject/onos:1.6
+      command: "docker pull {{ onos_docker_image }}"
 
 # Setup specific for onos-cord VM
 - hosts: onos-cord-1
@@ -23,22 +24,23 @@
   tasks:
     - name: Copy over SSH key
       copy:
-        src={{ node_private_key }}
-        dest={{ ansible_user_dir }}/cord/node_key
-        owner={{ ansible_user_id }} mode=0600
+        src: "{{ node_private_key }}"
+        dest: "{{ ansible_user_dir }}/cord/node_key"
+        owner: "{{ ansible_user_id }}"
+        mode: 0600
 
     - name: Copy over files to build XOS variant of ONOS
       copy:
-        src="~/{{ item }}"
-        dest="{{ ansible_user_dir }}/cord/{{ item }}"
+        src: "~/{{ item }}"
+        dest: "{{ ansible_user_dir }}/cord/{{ item }}"
       with_items:
        - Dockerfile.xos-onos
        - onos-service
 
     - name: Copy over & rename docker-compose file
       copy:
-        src=~/onos-docker-compose.yml
-        dest={{ ansible_user_dir }}/cord/docker-compose.yml
+        src: "~/onos-docker-compose.yml"
+        dest: "{{ ansible_user_dir }}/cord/docker-compose.yml"
 
 - hosts: onos-fabric-1
   remote_user: ubuntu
@@ -46,5 +48,5 @@
   tasks:
     - name: Copy over & rename docker-compose file
       copy:
-        src=~/fabric-docker-compose.yml
-        dest={{ ansible_user_dir }}/cord/docker-compose.yml
+        src: "~/fabric-docker-compose.yml"
+        dest: "{{ ansible_user_dir }}/cord/docker-compose.yml"
diff --git a/roles/onos-vm-install/tasks/main.yml b/roles/onos-vm-install/tasks/main.yml
index 24b3c43..bd3d073 100644
--- a/roles/onos-vm-install/tasks/main.yml
+++ b/roles/onos-vm-install/tasks/main.yml
@@ -3,25 +3,27 @@
 #
 # Install ONOS on a sub vm by calling ansible
 
-- name: Create a vars file from template
+- name: Create templated ONOS files
   template:
-    src=onos-setup-vars.yml.j2
-    dest={{ ansible_user_dir }}/onos-setup-vars.yml
+    src: "{{ item }}.j2"
+    dest: "{{ ansible_user_dir }}/{{ item }}"
+  with_items:
+    - onos-setup-vars.yml
+    - Dockerfile.xos-onos
+    - onos-service
 
-- name: Copy over ONOS playbook and docker compose files
+- name: Copy over ONOS playbook and other files
   copy:
-    src={{ item }}
-    dest={{ ansible_user_dir }}/{{ item }}
+    src: "{{ item }}"
+    dest: "{{ ansible_user_dir }}/{{ item }}"
   with_items:
     - onos-setup-playbook.yml
     - onos-docker-compose.yml
     - fabric-docker-compose.yml
-    - Dockerfile.xos-onos
-    - onos-service
 
 - name: Run the ONOS ansible playbook
   command: ansible-playbook {{ ansible_user_dir }}/onos-setup-playbook.yml
-  async: 1200
+  async: 1800
   poll: 0
   register: onos_setup_playbook
 
diff --git a/roles/onos-vm-install/templates/Dockerfile.xos-onos.j2 b/roles/onos-vm-install/templates/Dockerfile.xos-onos.j2
new file mode 100644
index 0000000..a9973be
--- /dev/null
+++ b/roles/onos-vm-install/templates/Dockerfile.xos-onos.j2
@@ -0,0 +1,20 @@
+# ONOS dockerfile with XOS/CORD additions
+
+FROM {{ onos_docker_image }}
+MAINTAINER Zack Williams <zdw@cs.arizona.edu>
+
+# Add SSL certs
+COPY xos-certs.crt /usr/local/share/ca-certificates/xos-certs.crt
+RUN update-ca-certificates
+
+# Create Java KeyStore from certs
+RUN openssl x509 -in /usr/local/share/ca-certificates/xos-certs.crt \
+      -outform der -out /usr/local/share/ca-certificates/xos-certs.der && \
+    keytool -import -noprompt -storepass {{ trust_store_pw }} -alias xos-certs \
+      -file /usr/local/share/ca-certificates/xos-certs.der \
+      -keystore /usr/local/share/ca-certificates/xos-certs.jks
+
+# Updated onos-service to use the jks
+COPY onos-service /root/onos/bin/onos-service
+RUN chmod 755 /root/onos/bin/onos-service
+
diff --git a/roles/onos-vm-install/files/onos-service b/roles/onos-vm-install/templates/onos-service.j2
similarity index 94%
rename from roles/onos-vm-install/files/onos-service
rename to roles/onos-vm-install/templates/onos-service.j2
index 7d810c4..7eef6f5 100644
--- a/roles/onos-vm-install/files/onos-service
+++ b/roles/onos-vm-install/templates/onos-service.j2
@@ -10,7 +10,7 @@
 # Do modify the keystore location/password and truststore location/password accordingly
 #export JAVA_OPTS="${JAVA_OPTS:--DenableNettyTLS=true -Djavax.net.ssl.keyStore=/home/ubuntu/onos.jks -Djavax.net.ssl.keyStorePassword=222222 -Djavax.net.ssl.trustStore=/home/ubuntu/onos.jks -Djavax.net.ssl.trustStorePassword=222222}"
 
-export JAVA_OPTS="-Djavax.net.ssl.trustStore=/usr/local/share/ca-certificates/xos-certs.jks -Djavax.net.ssl.trustStorePassword=222222" 
+export JAVA_OPTS="-Djavax.net.ssl.trustStore=/usr/local/share/ca-certificates/xos-certs.jks -Djavax.net.ssl.trustStorePassword={{ trust_store_pw }}" 
 
 set -e  # exit on error
 set -u  # exit on undefined variable
diff --git a/roles/onos-vm-install/templates/onos-setup-vars.yml.j2 b/roles/onos-vm-install/templates/onos-setup-vars.yml.j2
index 9e82c39..0d870f2 100644
--- a/roles/onos-vm-install/templates/onos-setup-vars.yml.j2
+++ b/roles/onos-vm-install/templates/onos-setup-vars.yml.j2
@@ -1,2 +1,7 @@
 ---
+# onos-vm-install/templates/onos-setup-vars.yml.j2
+
 node_private_key: "{{ ansible_user_dir }}/node_key"
+
+onos_docker_image: "{{ onos_docker_image }}"
+
