diff --git a/bin/bluetooth/bt-mgr/src/bond_defs.rs b/bin/bluetooth/bt-mgr/src/bond_defs.rs
index da401ce..86ced23 100644
--- a/bin/bluetooth/bt-mgr/src/bond_defs.rs
+++ b/bin/bluetooth/bt-mgr/src/bond_defs.rs
@@ -101,12 +101,47 @@
 #[derive(Serialize, Deserialize)]
 pub struct BondMap(HashMap<String, VecBondingData>);
 
-#[derive(Serialize, Deserialize)]
-struct VecBondingData {
-    #[serde(with = "VecBondData")]
-    inner: Vec<BondingData>,
+impl BondMap {
+    pub fn inner(&self) -> &HashMap<String, VecBondingData> {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut HashMap<String, VecBondingData> {
+        &mut self.0
+    }
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct VecBondingData {
+    #[serde(with = "VecBondData")]
+    pub inner: Vec<BondingData>,
+}
+
+//impl VecBondingData {
+//    pub fn inner(&self) -> VecBondingData {
+//        &self.inner
+//    }
+//}
+
+// TODO
+struct VecBondIter {}
+//
+//impl Iterator for VecBondIter {
+//    type Item = BondingData;
+//
+//    fn next(&mut self) -> Option<Self::Item> {
+//        self.inner.iter().next()
+//    }
+//}
+//impl IntoIterator for VecBondingData {
+//    type Item = BondingData;
+//    //type IntoIterator = VecBondIter;
+//
+//    //fn into_iter(self) -> Self::IntoIterator {
+//
+//    //}
+//}
+
 mod VecBondData {
     use super::{BondingData, BondingDataDef};
     use serde::Serializer;
diff --git a/bin/bluetooth/bt-mgr/src/bond_store.rs b/bin/bluetooth/bt-mgr/src/bond_store.rs
new file mode 100644
index 0000000..5210e17
--- /dev/null
+++ b/bin/bluetooth/bt-mgr/src/bond_store.rs
@@ -0,0 +1,109 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use app::client::App;
+use failure::{Error, ResultExt};
+use futures::future::ok as fok;
+use futures::{Future, FutureExt, StreamExt};
+use std::fs::File;
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use std::{thread, time};
+use toml;
+
+use app::client::Launcher;
+use fidl_bluetooth_bonder::{BonderEvent, BonderEventStream, BonderMarker, BondingData};
+use fidl_bluetooth_control::ControlMarker;
+use fidl_bluetooth_gatt::Server_Marker;
+use fidl_bluetooth_low_energy::{CentralMarker, PeripheralMarker};
+
+use bond_defs::BondMap;
+
+static BT_MGR_DIR: &'static str = "data/bt-mgr";
+
+pub struct BondStore {
+    bonds: BondMap,
+    bond_store: File,
+}
+
+impl BondStore {
+    pub fn load_store() -> Result<Self, Error> {
+        let store_path: PathBuf = [BT_MGR_DIR, "/bonds.toml"].iter().collect();
+
+        let mut bond_store = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(store_path)?;
+
+        let mut contents = String::new();
+        bond_store
+            .read_to_string(&mut contents)
+            .expect("The bond storage file is corrupted");
+        let bonds: BondMap = toml::from_str(contents.as_str()).unwrap();
+
+        Ok(BondStore { bonds, bond_store })
+    }
+
+    pub fn add(&mut self, local_id: String, bond_data: BondingData) {
+        self.bonds.inner_mut().entry(local_id)
+            //            TODO look up syntax, push if not there
+//            .or_insert(VecBondingData{inner: vec![]})
+            .and_modify(move |entry| {
+                entry.inner.push(bond_data);
+            });
+        let _ = self.save_state();
+    }
+
+    pub fn bonds(&self) -> &BondMap {
+        &self.bonds
+    }
+
+    pub fn save_state(&mut self) -> Result<(), Error> {
+        let toml = toml::to_string_pretty(&self.bonds)?;
+        self.bond_store.write_all(toml.as_bytes())?;
+        self.bond_store.sync_data()?;
+        Ok(())
+    }
+}
+
+pub fn bond(bond_store: Arc<Mutex<BondStore>>, bt_gap: App) -> Result<(), Error> {
+    let bond_svc = bt_gap.connect_to_service(BonderMarker)?;
+
+    let bond_store = bond_store.lock().unwrap();
+    for (bond_key, bond_data) in bond_store.bonds.inner().iter() {
+        // TODO make the iter work
+        //        bond_svc.add_bonded_devices(bond_key, bond_data.into_iter());
+    }
+
+    Ok(())
+}
+
+pub fn watch_bonds(
+    bond_store: Arc<Mutex<BondStore>>,
+) -> impl Future<Item = BonderEventStream, Error = Error> {
+    let launcher = Launcher::new()
+        .context("Failed to open launcher service")
+        .unwrap();
+    let app = launcher
+        .launch(String::from("bt-gap"), None)
+        .context("Failed to launch bt-gap (bluetooth) service")
+        .unwrap();
+    thread::sleep(time::Duration::from_millis(2000));
+    let app = app.connect_to_service(BonderMarker);
+    let stream = app.unwrap().take_event_stream();
+    stream
+        .for_each(move |evt| {
+            match evt {
+                BonderEvent::OnNewBondingData { local_id, data } => {
+                    let mut bond_store = bond_store.lock().unwrap();
+                    bond_store.add(local_id, data)
+                }
+            }
+            fok(())
+        })
+        .err_into()
+}
diff --git a/bin/bluetooth/bt-mgr/src/main.rs b/bin/bluetooth/bt-mgr/src/main.rs
index 802dea3..12fc077 100644
--- a/bin/bluetooth/bt-mgr/src/main.rs
+++ b/bin/bluetooth/bt-mgr/src/main.rs
@@ -10,9 +10,13 @@
 extern crate fidl;
 extern crate fidl_bluetooth_bonder;
 extern crate fidl_bluetooth_control;
+extern crate fidl_bluetooth_gatt;
+extern crate fidl_bluetooth_low_energy;
 extern crate fuchsia_app as app;
 extern crate fuchsia_async as async;
 extern crate fuchsia_zircon as zx;
+#[macro_use]
+extern crate fuchsia_bluetooth as bt;
 extern crate futures;
 extern crate parking_lot;
 #[macro_use]
@@ -22,73 +26,47 @@
 extern crate serde;
 extern crate toml;
 
-use std::io::Read;
-use std::path::PathBuf;
-
 use fidl::endpoints2::ServiceMarker;
 use std::{thread, time};
 
 use app::client::App;
 use std::sync::{Arc, Mutex};
 
-use std::fs::File;
-use std::fs::OpenOptions;
-
-use std::io::Write;
+use futures::future::ok as fok;
+use futures::{Future, FutureExt, StreamExt};
 
 use app::client::Launcher;
 use app::server::ServicesServer;
 use failure::{Error, ResultExt};
-use fidl_bluetooth_bonder::BonderMarker;
 use fidl_bluetooth_control::ControlMarker;
+use fidl_bluetooth_gatt::Server_Marker;
+use fidl_bluetooth_low_energy::{CentralMarker, PeripheralMarker};
 
 mod bond_defs;
+mod bond_store;
 mod logger;
 
 use bond_defs::*;
+use bond_store::BondStore;
 
 const MAX_LOG_LEVEL: log::LevelFilter = log::LevelFilter::Info;
 static LOGGER: logger::Logger = logger::Logger;
 
-static BT_MGR_DIR: &'static str = "data/bt-mgr";
-
-struct BondStore {
-    bonds: BondMap,
-    bond_store: File,
-}
-
-impl BondStore {
-    fn load_store() -> Result<Self, Error> {
-        let store_path: PathBuf = [BT_MGR_DIR, "/bonds.toml"].iter().collect();
-
-        let mut bond_store = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(store_path)?;
-
-        let mut contents = String::new();
-        bond_store
-            .read_to_string(&mut contents)
-            .expect("The bond storage file is corrupted");
-        let bonds: BondMap = toml::from_str(contents.as_str()).unwrap();
-
-        Ok(BondStore { bonds, bond_store })
-    }
-
-    fn save_state(&mut self) -> Result<(), Error> {
-        let toml = toml::to_string_pretty(&self.bonds)?;
-        self.bond_store.write_all(toml.as_bytes())?;
-        self.bond_store.sync_data()?;
-        Ok(())
-    }
-}
-
-fn bond(_bond_store: Arc<Mutex<BondStore>>, bt_gap: App) -> Result<(), Error> {
-    let _bond_svc = bt_gap.connect_to_service(BonderMarker)?;
-
-    //bond_svc.add_bonded_devices();
-    Ok(())
+fn launch_bt_gap<S: ServiceMarker>(
+    marker: S, bond_store: Arc<Mutex<BondStore>>, chan: async::Channel,
+) {
+    let launcher = Launcher::new()
+        .context("Failed to open launcher service")
+        .unwrap();
+    let app = launcher
+        .launch(String::from("bt-gap"), None)
+        .context("Failed to launch bt-gap (bluetooth) service")
+        .unwrap();
+    // TODO check if we need to launch a service?
+    thread::sleep(time::Duration::from_millis(2000));
+    let _ = app.pass_to_service(marker, chan.into());
+    // TODO cap the number of times this is done?
+    let _ = bond_store::bond(bond_store.clone(), app);
 }
 
 fn main() -> Result<(), Error> {
@@ -99,25 +77,33 @@
     let mut executor = async::Executor::new().context("Error creating executor")?;
 
     let bond_store = Arc::new(Mutex::new(BondStore::load_store()?));
+    make_clones!(bond_store => control_bs, central_bs, peripheral_bs, server_bs, bond_bs);
+
+    let bond_watcher = bond_store::watch_bonds(bond_bs);
+
     let server = ServicesServer::new()
         .add_service((ControlMarker::NAME, move |chan: async::Channel| {
             info!("Passing Control Handle to bt-gap");
-            let launcher = Launcher::new()
-                .context("Failed to open launcher service")
-                .unwrap();
-            let app = launcher
-                .launch(String::from("bt-gap"), None)
-                .context("Failed to launch bt-gap (bluetooth) service")
-                .unwrap();
-            thread::sleep(time::Duration::from_millis(2000));
-            let _ = app.pass_to_service(ControlMarker, chan.into());
-            let _ = bond(bond_store.clone(), app);
+            launch_bt_gap(ControlMarker, control_bs.clone(), chan);
+        }))
+        .add_service((CentralMarker::NAME, move |chan: async::Channel| {
+            info!("Passing LE Central Handle to bt-gap");
+            launch_bt_gap(CentralMarker, central_bs.clone(), chan);
+        }))
+        .add_service((PeripheralMarker::NAME, move |chan: async::Channel| {
+            info!("Passing Peripheral Handle to bt-gap");
+            launch_bt_gap(PeripheralMarker, peripheral_bs.clone(), chan);
+        }))
+        .add_service((Server_Marker::NAME, move |chan: async::Channel| {
+            info!("Passing GATT Handle to bt-gap");
+            launch_bt_gap(Server_Marker, server_bs.clone(), chan);
         }))
         .start()
         .map_err(|e| e.context("error starting service server"))?;
 
     executor
-        .run_singlethreaded(server)
+        .run_singlethreaded(server.join(bond_watcher))
         .context("bt-mgr failed to execute future")
+        .map(|_| ())
         .map_err(|e| e.into())
 }