diff --git a/Makefile.am b/Makefile.am
index 0129c2b..94a88f6 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -5,6 +5,8 @@
 nobase_include_HEADERS = \
 	mapbox/recursive_wrapper.hpp \
 	mapbox/variant.hpp \
+	sdbusplus/asio/connection.hpp \
+	sdbusplus/asio/detail/async_send_handler.hpp \
 	sdbusplus/bus.hpp \
 	sdbusplus/bus/match.hpp \
 	sdbusplus/sdbus.hpp \
@@ -22,6 +24,7 @@
 	sdbusplus/server/object.hpp \
 	sdbusplus/slot.hpp \
 	sdbusplus/utility/container_traits.hpp \
+	sdbusplus/utility/read_into_tuple.hpp \
 	sdbusplus/utility/tuple_to_array.hpp \
 	sdbusplus/utility/type_traits.hpp \
 	sdbusplus/vtable.hpp
diff --git a/configure.ac b/configure.ac
index c3d8554..753d04d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -133,6 +133,10 @@
     AC_SUBST([OESDK_TESTCASE_FLAGS], [$testcase_flags])
 )
 
+AC_ARG_ENABLE([boost],
+    AS_HELP_STRING([--enable-boost], [Enable building with boost.]))
+AM_CONDITIONAL(BOOST, [test "x$enable_boost" = "xyes"])
+
 # Create configured output
 AC_CONFIG_FILES([Makefile test/Makefile tools/Makefile tools/setup.py])
 AC_CONFIG_FILES([example/Makefile])
diff --git a/example/Makefile.am b/example/Makefile.am
index 2cf8941..86ab50a 100644
--- a/example/Makefile.am
+++ b/example/Makefile.am
@@ -1,5 +1,26 @@
 noinst_PROGRAMS = calculator-server list-users
 
+if BOOST
+noinst_PROGRAMS += asio-example
+asio_example_SOURCES = asio-example.cpp
+asio_example_CXXFLAGS = \
+    $(SYSTEMD_CFLAGS) \
+    $(PTHREAD_CFLAGS) \
+    $(BOOST_CPPFLAGS) \
+    -DBOOST_ALL_NO_LIB \
+    -DBOOST_SYSTEM_NO_DEPRECATED \
+    -DBOOST_ERROR_CODE_HEADER_ONLY \
+    -I$(top_srcdir)
+
+asio_example_LDADD = \
+    $(SYSTEMD_LIBS) \
+    $(PTHREAD_LIBS) \
+    ../libsdbusplus.la
+
+asio_example_LDFLAGS = \
+    $(BOOST_LDFLAGS)
+endif
+
 calculator_server_generated_files = \
 	net/poettering/Calculator/server.hpp \
 	net/poettering/Calculator/server.cpp \
diff --git a/example/asio-example.cpp b/example/asio-example.cpp
new file mode 100644
index 0000000..7dde720
--- /dev/null
+++ b/example/asio-example.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/server.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <boost/asio.hpp>
+
+int main()
+{
+    using GetSubTreeType = std::vector<std::pair<
+        std::string,
+        std::vector<std::pair<std::string, std::vector<std::string>>>>>;
+    using message = sdbusplus::message::message;
+    // setup connection to dbus
+    boost::asio::io_service io;
+    auto conn = std::make_shared<sdbusplus::asio::connection>(io);
+
+    // test async method call and async send
+    auto mesg =
+        conn->new_method_call("xyz.openbmc_project.ObjectMapper",
+                              "/xyz/openbmc_project/object_mapper",
+                              "xyz.openbmc_project.ObjectMapper", "GetSubTree");
+
+    static const auto depth = 2;
+    static const std::vector<std::string> interfaces = {
+        "xyz.openbmc_project.Sensor.Value"};
+    mesg.append("/xyz/openbmc_project/Sensors", depth, interfaces);
+
+    conn->async_send(mesg, [](boost::system::error_code ec, message& ret) {
+        std::cout << "async_send callback\n";
+        if (ec || ret.is_method_error())
+        {
+            std::cerr << "error with async_send\n";
+            return;
+        }
+        GetSubTreeType data;
+        ret.read(data);
+        for (auto& item : data)
+        {
+            std::cout << item.first << "\n";
+        }
+    });
+
+    conn->async_method_call(
+        [](boost::system::error_code ec, GetSubTreeType& subtree) {
+            std::cout << "async_method_call callback\n";
+            if (ec)
+            {
+                std::cerr << "error with async_method_call\n";
+                return;
+            }
+            for (auto& item : subtree)
+            {
+                std::cout << item.first << "\n";
+            }
+
+        },
+        "xyz.openbmc_project.ObjectMapper",
+        "/xyz/openbmc_project/object_mapper",
+        "xyz.openbmc_project.ObjectMapper", "GetSubTree",
+        "/org/openbmc/control", 2, std::vector<std::string>());
+
+    io.run();
+
+    return 0;
+}
diff --git a/sdbusplus/asio/connection.hpp b/sdbusplus/asio/connection.hpp
new file mode 100644
index 0000000..e306113
--- /dev/null
+++ b/sdbusplus/asio/connection.hpp
@@ -0,0 +1,127 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+#pragma once
+
+#include <sdbusplus/message.hpp>
+#include <sdbusplus/utility/read_into_tuple.hpp>
+#include <sdbusplus/utility/type_traits.hpp>
+#include <sdbusplus/asio/detail/async_send_handler.hpp>
+#include <chrono>
+#include <string>
+#include <experimental/tuple>
+#include <boost/asio.hpp>
+#include <boost/callable_traits.hpp>
+
+namespace sdbusplus
+{
+
+namespace asio
+{
+
+/// Root D-Bus IO object
+/**
+ * A connection to a bus, through which messages may be sent or received.
+ */
+class connection : public sdbusplus::bus::bus
+{
+  public:
+    // default to system bus
+    connection(boost::asio::io_service& io) :
+        sdbusplus::bus::bus(sdbusplus::bus::new_system()), io_(io), socket(io_)
+    {
+        socket.assign(get_fd());
+        do_read();
+    }
+    connection(boost::asio::io_service& io, sd_bus* bus) :
+        sdbusplus::bus::bus(bus), io_(io), socket(io_)
+    {
+        socket.assign(get_fd());
+        do_read();
+    }
+    ~connection()
+    {
+        // The FD will be closed by the socket object, so assign null to the
+        // sd_bus object to avoid a double close()  Ignore return codes here,
+        // because there's nothing we can do about errors
+        socket.release();
+    }
+
+    template <typename MessageHandler>
+    inline BOOST_ASIO_INITFN_RESULT_TYPE(MessageHandler,
+                                         void(boost::system::error_code,
+                                              message::message))
+        async_send(message::message& m, MessageHandler&& handler)
+    {
+        boost::asio::async_completion<
+            MessageHandler, void(boost::system::error_code, message::message)>
+            init(handler);
+        detail::async_send_handler<typename boost::asio::handler_type<
+            MessageHandler,
+            void(boost::system::error_code, message::message)>::type>(
+            std::move(init.completion_handler))(get(), m);
+        return init.result.get();
+    }
+
+    template <typename MessageHandler, typename... InputArgs>
+    auto async_method_call(MessageHandler handler, const std::string& service,
+                           const std::string& objpath,
+                           const std::string& interf, const std::string& method,
+                           const InputArgs&... a)
+    {
+        message::message m = new_method_call(service.c_str(), objpath.c_str(),
+                                             interf.c_str(), method.c_str());
+        m.append(a...);
+        return async_send(m, [handler](boost::system::error_code ec,
+                                       message::message& r) {
+            using FunctionTuple =
+                boost::callable_traits::args_t<MessageHandler>;
+            using UnpackType = typename utility::strip_first_arg<
+                typename utility::decay_tuple<FunctionTuple>::type>::type;
+            UnpackType responseData;
+            if (!ec)
+            {
+                if (!utility::read_into_tuple(responseData, r))
+                {
+                    // Set error code if not already set
+                    ec = boost::system::errc::make_error_code(
+                        boost::system::errc::invalid_argument);
+                }
+            }
+            // Note.  Callback is called whether or not the unpack was
+            // sucessful to allow the user to implement their own handling
+            auto response = std::tuple_cat(std::make_tuple(ec), responseData);
+            std::experimental::apply(handler, response);
+        });
+    }
+
+  private:
+    boost::asio::io_service& io_;
+    boost::asio::posix::stream_descriptor socket;
+
+    void do_read(void)
+    {
+        socket.async_read_some(
+            boost::asio::null_buffers(),
+            [&](const boost::system::error_code& ec, std::size_t) {
+                process_discard();
+                do_read();
+            });
+    }
+};
+
+} // namespace asio
+
+} // namespace sdbusplus
diff --git a/sdbusplus/asio/detail/async_send_handler.hpp b/sdbusplus/asio/detail/async_send_handler.hpp
new file mode 100644
index 0000000..e9e036d
--- /dev/null
+++ b/sdbusplus/asio/detail/async_send_handler.hpp
@@ -0,0 +1,70 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+#pragma once
+
+#include <sdbusplus/message.hpp>
+#include <sdbusplus/bus.hpp>
+#include <systemd/sd-bus.h>
+#include <boost/asio.hpp>
+
+namespace sdbusplus
+{
+namespace asio
+{
+namespace detail
+{
+template <typename Handler> struct async_send_handler
+{
+    Handler handler_;
+    async_send_handler(Handler&& handler) : handler_(std::move(handler))
+    {
+    }
+    async_send_handler(Handler& handler) : handler_(handler)
+    {
+    }
+    void operator()(sd_bus* conn, message::message& mesg)
+    {
+        async_send_handler* context = new async_send_handler(std::move(*this));
+        // 0 is the default timeout
+        int ec =
+            sd_bus_call_async(conn, NULL, mesg.get(), &callback, context, 0);
+        if (ec < 0)
+        {
+            auto err =
+                make_error_code(static_cast<boost::system::errc::errc_t>(ec));
+            context->handler_(err, mesg);
+            delete context;
+        }
+    }
+    static int callback(sd_bus_message* mesg, void* userdata,
+                        sd_bus_error* error)
+    {
+        if (userdata == nullptr || mesg == nullptr)
+        {
+            return -1;
+        }
+        std::unique_ptr<async_send_handler> context(
+            static_cast<async_send_handler*>(userdata));
+        message::message message(mesg);
+        auto ec = make_error_code(
+            static_cast<boost::system::errc::errc_t>(message.get_errno()));
+        context->handler_(ec, message);
+        return 1;
+    }
+};
+} // namespace detail
+} // namespace asio
+} // namespace sdbusplus
\ No newline at end of file
diff --git a/sdbusplus/bus.hpp.in b/sdbusplus/bus.hpp.in
index 1f13a5e..638a515 100644
--- a/sdbusplus/bus.hpp.in
+++ b/sdbusplus/bus.hpp.in
@@ -282,6 +282,10 @@
         return std::string(unique);
     }
 
+    auto get_fd(){
+        return sd_bus_get_fd(_bus.get());
+    }
+
     /** @brief Attach the bus with a sd-event event loop object.
      *
      *  @param[in] event - sd_event object.
@@ -400,7 +404,7 @@
     template <class... Args> friend struct server::object::object;
     friend struct match::match;
 
-  private:
+  protected:
     busp_t get()
     {
         return _bus.get();
diff --git a/sdbusplus/message.hpp b/sdbusplus/message.hpp
index 6b58099..d6b5aa7 100644
--- a/sdbusplus/message.hpp
+++ b/sdbusplus/message.hpp
@@ -193,6 +193,15 @@
         return _intf->sd_bus_message_is_method_error(_msg.get(), nullptr);
     }
 
+    /** @brief Get the errno from the message.
+     *
+     *  @return The errno of the message.
+     */
+    int get_errno()
+    {
+        return sd_bus_message_get_errno(_msg.get());
+    }
+
     /** @brief Get the transaction cookie of a message.
      *
      * @return The transaction cookie of a message.
@@ -254,12 +263,13 @@
 
     friend struct sdbusplus::bus::bus;
 
-  private:
     /** @brief Get a pointer to the owned 'msgp_t'. */
     msgp_t get()
     {
         return _msg.get();
     }
+
+  private:
     sdbusplus::SdBusInterface* _intf;
     details::msg _msg;
 };
diff --git a/sdbusplus/utility/read_into_tuple.hpp b/sdbusplus/utility/read_into_tuple.hpp
new file mode 100644
index 0000000..9628e11
--- /dev/null
+++ b/sdbusplus/utility/read_into_tuple.hpp
@@ -0,0 +1,51 @@
+/*
+// Copyright (c) 2018 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#pragma once
+#include <tuple>
+#include <sdbusplus/message.hpp>
+
+namespace sdbusplus
+{
+namespace utility
+{
+
+namespace detail
+{
+template <class F, size_t... Is>
+constexpr auto index_apply_impl(F f, std::index_sequence<Is...>)
+{
+    return f(std::integral_constant<size_t, Is>{}...);
+}
+template <size_t N, class F> constexpr auto index_apply(F f)
+{
+    return index_apply_impl(f, std::make_index_sequence<N>{});
+}
+} // namespace detail
+template <class Tuple>
+constexpr bool read_into_tuple(Tuple& t, message::message& m)
+{
+    return detail::index_apply<std::tuple_size<Tuple>{}>([&](auto... Is) {
+        if (m.is_method_error())
+        {
+            return false;
+        }
+        m.read(std::get<Is>(t)...);
+        return true;
+    });
+}
+} // namespace utility
+} // namespace sdbusplus
diff --git a/sdbusplus/utility/type_traits.hpp b/sdbusplus/utility/type_traits.hpp
index cad5168..3629d09 100644
--- a/sdbusplus/utility/type_traits.hpp
+++ b/sdbusplus/utility/type_traits.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <type_traits>
+#include <tuple>
 
 namespace sdbusplus
 {
@@ -20,6 +21,28 @@
                        std::add_pointer_t<std::remove_extent_t<T>>, T>,
     T>;
 
+// Small helper class for stripping off the error code from the function
+// argument definitions so unpack can be called appropriately
+template <typename T> struct strip_first_arg
+{
+};
+
+template <typename FirstArg, typename... Rest>
+struct strip_first_arg<std::tuple<FirstArg, Rest...>>
+{
+    using type = std::tuple<Rest...>;
+};
+
+// helper class to remove const and reference from types
+template <typename T> struct decay_tuple
+{
+};
+
+template <typename... Args> struct decay_tuple<std::tuple<Args...>>
+{
+    using type = std::tuple<typename std::decay<Args>::type...>;
+};
+
 } // namespace utility
 
 } // namespace sdbusplus