diff --git a/garnet/packages/prod/BUILD.gn b/garnet/packages/prod/BUILD.gn
index 09734a9..3309368 100644
--- a/garnet/packages/prod/BUILD.gn
+++ b/garnet/packages/prod/BUILD.gn
@@ -303,6 +303,8 @@
   public_deps = [
     "//src/connectivity/telephony/drivers/qmi-fake-transport",
     "//src/connectivity/telephony/drivers/qmi-usb-transport",
+    "//src/connectivity/telephony/ril-at",
+    "//src/connectivity/telephony/ril-at:ril-at-tests",
     "//src/connectivity/telephony/ril-qmi",
     "//src/connectivity/telephony/ril-qmi:ril-qmi-tests",
     "//src/connectivity/telephony/telephony",
diff --git a/sdk/fidl/fuchsia.telephony.ril/ril.fidl b/sdk/fidl/fuchsia.telephony.ril/ril.fidl
index 3d2488e..5aab3ac 100644
--- a/sdk/fidl/fuchsia.telephony.ril/ril.fidl
+++ b/sdk/fidl/fuchsia.telephony.ril/ril.fidl
@@ -71,4 +71,7 @@
 
     /// Signal Strength (dBm) for LTE networks (total received wideband power).
     GetSignalStrength() -> (float32 dbm) error RilError;
+
+    /// Raw string to send to modem for development.
+    RawCommand(string command) -> (string result) error RilError;
 };
diff --git a/src/connectivity/telephony/BUILD.gn b/src/connectivity/telephony/BUILD.gn
index 2456bb9..e801eec 100644
--- a/src/connectivity/telephony/BUILD.gn
+++ b/src/connectivity/telephony/BUILD.gn
@@ -7,6 +7,7 @@
   public_deps = [
     ":tests",
     "//src/connectivity/telephony/config",
+    "//src/connectivity/telephony/ril-at",
     "//src/connectivity/telephony/ril-qmi",
     "//src/connectivity/telephony/telephony",
     "//src/connectivity/telephony/tools",
diff --git a/src/connectivity/telephony/ril-at/BUILD.gn b/src/connectivity/telephony/ril-at/BUILD.gn
new file mode 100644
index 0000000..81898b3
--- /dev/null
+++ b/src/connectivity/telephony/ril-at/BUILD.gn
@@ -0,0 +1,56 @@
+# 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.
+
+import("//build/package.gni")
+import("//build/rust/rustc_binary.gni")
+import("//build/test/test_package.gni")
+import("//build/testing/environments.gni")
+
+rustc_binary("bin") {
+  name = "ril_at"
+  edition = "2018"
+  with_unit_tests = true
+
+  deps = [
+    "//sdk/fidl/fuchsia.telephony.ril:fuchsia.telephony.ril-rustc",
+    "//src/connectivity/telephony/lib/qmi-protocol",
+    "//src/lib/fidl/rust/fidl",
+    "//src/lib/fuchsia-async",
+    "//src/lib/fuchsia-component",
+    "//src/lib/syslog/rust:syslog",
+    "//src/lib/zircon/rust:fuchsia-zircon",
+    "//third_party/rust_crates:anyhow",
+    "//third_party/rust_crates:bytes",
+    "//third_party/rust_crates:futures",
+    "//third_party/rust_crates:log",
+    "//third_party/rust_crates:parking_lot",
+  ]
+}
+
+package("ril-at") {
+  deps = [ ":bin" ]
+
+  binary = "ril_at"
+
+  meta = [
+    {
+      path = rebase_path("meta/ril-at.cmx")
+      dest = "ril-at.cmx"
+    },
+  ]
+}
+
+unittest_package("ril-at-tests") {
+  package_name = "ril-at-tests"
+
+  deps = [ ":bin_test" ]
+
+  tests = [
+    {
+      name = "ril_at_bin_test"
+      dest = "ril-at-tests"
+      environments = basic_envs
+    },
+  ]
+}
diff --git a/src/connectivity/telephony/ril-at/meta/ril-at.cmx b/src/connectivity/telephony/ril-at/meta/ril-at.cmx
new file mode 100644
index 0000000..2015a8d
--- /dev/null
+++ b/src/connectivity/telephony/ril-at/meta/ril-at.cmx
@@ -0,0 +1,10 @@
+{
+    "program": {
+        "binary": "bin/app"
+    },
+    "sandbox": {
+        "services": [
+            "fuchsia.logger.LogSink"
+        ]
+    }
+}
diff --git a/src/connectivity/telephony/ril-at/src/main.rs b/src/connectivity/telephony/ril-at/src/main.rs
new file mode 100644
index 0000000..5e6a5e0
--- /dev/null
+++ b/src/connectivity/telephony/ril-at/src/main.rs
@@ -0,0 +1,162 @@
+// Copyright 2020 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 crate::transport::AtTransport;
+use anyhow::Error;
+use fidl_fuchsia_telephony_ril::*;
+use fuchsia_async as fasync;
+use fuchsia_component::server::ServiceFs;
+use fuchsia_syslog::{self as syslog, macros::*};
+use fuchsia_zircon as zx;
+use futures::{
+    future::Future,
+    lock::Mutex,
+    task::{AtomicWaker, Context},
+    StreamExt, TryFutureExt, TryStreamExt,
+};
+use std::{pin::Pin, sync::Arc, task::Poll};
+
+mod transport;
+
+pub struct AtModem {
+    transport: Option<AtTransport>,
+    waker: AtomicWaker,
+}
+
+impl AtModem {
+    pub fn new() -> Self {
+        AtModem { transport: None, waker: AtomicWaker::new() }
+    }
+
+    async fn fidl_service_async(modem: Arc<Mutex<AtModem>>, mut stream: SetupRequestStream) -> () {
+        let mut modem = modem.lock().await;
+        let res = stream.next().await;
+        if let Some(Ok(SetupRequest::ConnectTransport { channel, responder })) = res {
+            let status = modem.connect_transport(channel);
+            fx_log_info!("Connecting the service to the transport driver: {}", status);
+            if status {
+                let _result = responder.send(&mut Ok(()));
+            } else {
+                let _result = responder.send(&mut Err(RilError::TransportError));
+            }
+        }
+    }
+
+    pub fn fidl_service(modem: Arc<Mutex<AtModem>>) -> impl Fn(SetupRequestStream) -> () {
+        move |stream| fasync::spawn(AtModem::fidl_service_async(modem.clone(), stream))
+    }
+
+    fn connect_transport(&mut self, chan: zx::Channel) -> bool {
+        fx_log_info!("Connecting the transport");
+        match fasync::Channel::from_channel(chan) {
+            Ok(chan) => {
+                if chan.is_closed() {
+                    fx_log_err!("The transport channel is not open");
+                    return false;
+                }
+                self.set_transport(AtTransport::new(chan));
+                true
+            }
+            Err(_) => {
+                fx_log_err!("Failed to convert a zircon channel to a fasync one");
+                false
+            }
+        }
+    }
+
+    fn set_transport(&mut self, transport: AtTransport) {
+        self.transport = Some(transport);
+        self.waker.wake();
+    }
+}
+
+//Wait for transport setup.
+impl<'modem> Future for &AtModem {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match self.transport {
+            Some(_) => Poll::Ready(()),
+            None => {
+                self.waker.register(cx.waker());
+                Poll::Pending
+            }
+        }
+    }
+}
+
+/// Craft a AT Query given a handle and a client connection. Handles common error paths.
+/// For more specialized interactions with the modem, prefer to call `client.send_msg()` directly.
+macro_rules! at_query {
+    ($responder:expr, $transport:expr, $query:expr) => {{
+        match $transport.send_msg($query).await {
+            Ok(at) => at,
+            Err(e) => {
+                fx_log_err!("Transport Error: {:?}", e);
+                return $responder.send(&mut Err(RilError::TransportError));
+            }
+        }
+    }};
+}
+
+struct FrilService;
+impl FrilService {
+    pub fn fidl_service(
+        modem: Arc<Mutex<AtModem>>,
+    ) -> impl Fn(RadioInterfaceLayerRequestStream) -> () {
+        move |stream: RadioInterfaceLayerRequestStream| {
+            fx_log_info!("New client connecting to the Fuchsia RIL");
+            fasync::spawn(FrilService::fidl_service_async(modem.clone(), stream))
+        }
+    }
+
+    async fn fidl_service_async(
+        modem: Arc<Mutex<AtModem>>,
+        stream: RadioInterfaceLayerRequestStream,
+    ) {
+        stream
+            .try_for_each(move |req| Self::handle_request(modem.clone(), req))
+            .unwrap_or_else(|e| fx_log_err!("Error running {:?}", e))
+            .await
+    }
+
+    async fn handle_request(
+        modem: Arc<Mutex<AtModem>>,
+        request: RadioInterfaceLayerRequest,
+    ) -> Result<(), fidl::Error> {
+        let mut modem = modem.lock().await;
+        (&(*modem)).await; // Await transport setup.
+        // This await  is ok since the transport has been set up.
+        let transport = (&mut modem.transport).as_mut().unwrap(); 
+        match request {
+            RadioInterfaceLayerRequest::RawCommand { command, responder } => {
+                let resp = at_query!(responder, transport, command);
+
+                responder.send(&mut Ok(resp))?;
+            }
+            // Translate requests here
+            _ => (),
+        }
+        Ok(())
+    }
+}
+
+#[fasync::run_singlethreaded]
+async fn main() -> Result<(), Error> {
+    syslog::init_with_tags(&["ril-at"]).expect("Can't init logger");
+    fx_log_info!("Starting ril-at...");
+
+    let modem = Arc::new(Mutex::new(AtModem::new()));
+
+    let mut fs = ServiceFs::new_local();
+    let mut dir = fs.dir("svc");
+
+    // Add connection to upstream clients.
+    dir.add_fidl_service(FrilService::fidl_service(modem.clone()));
+    // Add connection to downstream driver.
+    dir.add_fidl_service(AtModem::fidl_service(modem.clone()));
+
+    fs.take_and_serve_directory_handle()?;
+    Ok(fs.collect::<()>().await)
+}
diff --git a/src/connectivity/telephony/ril-at/src/transport.rs b/src/connectivity/telephony/ril-at/src/transport.rs
new file mode 100644
index 0000000..824b76e
--- /dev/null
+++ b/src/connectivity/telephony/ril-at/src/transport.rs
@@ -0,0 +1,123 @@
+// 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 fuchsia_async as fasync;
+use fuchsia_zircon as zx;
+use futures::lock::Mutex;
+use std::{collections::VecDeque, str::Utf8Error, sync::Arc};
+
+#[derive(Clone, Debug)]
+pub enum AtTransportError {
+    ChannelClosed,
+    ClientRead { error: zx::Status },
+    ClientWrite { error: zx::Status },
+    Deserialize { bytes: Vec<u8>, error: Utf8Error },
+}
+
+struct AtMessage {
+    request: String,
+    response: Option<Result<String, AtTransportError>>,
+}
+
+impl AtMessage {
+    fn new(request: String) -> Arc<Mutex<Self>> {
+        Arc::new(Mutex::new(AtMessage { request, response: None }))
+    }
+}
+
+pub struct AtTransport {
+    messages: Mutex<VecDeque<Arc<Mutex<AtMessage>>>>,
+    transport_channel: Mutex<fasync::Channel>,
+}
+
+impl AtTransport {
+    pub fn new(chan: fasync::Channel) -> Self {
+        AtTransport { transport_channel: Mutex::new(chan), messages: Mutex::new(VecDeque::new()) }
+    }
+
+    pub async fn send_msg(&mut self, string_msg: String) -> Result<String, AtTransportError> {
+        let msg = self.enqueue_message(string_msg).await;
+        self.do_sends_and_recvs().await;
+
+        let msg = msg.lock().await;
+        msg.response.clone().unwrap() // Unwraps the option set in do_sends_and_recvs
+    }
+
+    async fn enqueue_message(&self, string_msg: String) -> Arc<Mutex<AtMessage>> {
+        let msg = AtMessage::new(string_msg);
+
+        let messages = &mut self.messages.lock().await;
+        messages.push_back(msg.clone());
+
+        msg
+    }
+
+    async fn do_sends_and_recvs(&mut self) -> () {
+        // Serialize message send/recvs.
+        let transport_channel = self.transport_channel.lock().await;
+
+        'messages: loop {
+            let message = {
+                let mut messages = self.messages.lock().await;
+                match messages.pop_front() {
+                    None => break 'messages,
+                    Some(m) => m,
+                }
+            };
+            let mut message = message.lock().await;
+
+            let response = self.send_one(&transport_channel, &message.request).await;
+            message.response = Some(response);
+        }
+    }
+
+    async fn send_one(
+        &self,
+        transport: &fasync::Channel,
+        request: &String,
+    ) -> Result<String, AtTransportError> {
+        let request_bytes = Self::serialize_request(request);
+
+        transport
+            .write(&request_bytes, /* no handles */ &mut vec![])
+            .map_err(|error| AtTransportError::ClientWrite { error })?;
+
+        // Loop over unsolicited events until we get a response or an error.
+        loop {
+            let response_buf = Self::recv(transport).await?;
+            let response = Self::deserialize_response(response_buf.bytes().to_vec())?;
+
+            if Self::is_unsolicited_event(&response) {
+                // TODO Handle these
+            } else {
+                return Ok(response);
+            }
+        }
+    }
+
+    fn serialize_request(request: &String) -> Vec<u8> {
+        request.as_bytes().to_vec()
+    }
+
+    fn deserialize_response(response_bytes: Vec<u8>) -> Result<String, AtTransportError> {
+        String::from_utf8(response_bytes).map_err(|error| AtTransportError::Deserialize {
+            bytes: error.as_bytes().to_vec(),
+            error: error.utf8_error(),
+        })
+    }
+
+    fn is_unsolicited_event(_response: &String) -> bool {
+        // TODO Fix this.
+        false
+    }
+
+    async fn recv(transport_channel: &fasync::Channel) -> Result<zx::MessageBuf, AtTransportError> {
+        let mut response_buf = zx::MessageBuf::new();
+        match transport_channel.recv_msg(&mut response_buf).await {
+            Ok(()) => return Ok(response_buf),
+            Err(zx::Status::PEER_CLOSED) => return Err(AtTransportError::ChannelClosed),
+            Err(error) => return Err(AtTransportError::ClientRead { error }),
+        }
+    }
+}
diff --git a/src/connectivity/telephony/ril-qmi/src/main.rs b/src/connectivity/telephony/ril-qmi/src/main.rs
index 874f724..2ad62a7 100644
--- a/src/connectivity/telephony/ril-qmi/src/main.rs
+++ b/src/connectivity/telephony/ril-qmi/src/main.rs
@@ -187,6 +187,9 @@
                     responder.send(&mut Ok(RadioPowerState::Off))?
                 }
             }
+            RadioInterfaceLayerRequest::RawCommand { command: _command, responder } => {
+                responder.send(&mut Err(RilError::UnknownError))?
+            }
         }
         Ok(())
     }
diff --git a/src/connectivity/telephony/tests/BUILD.gn b/src/connectivity/telephony/tests/BUILD.gn
index 5bd2a3c..6bdd3f3 100644
--- a/src/connectivity/telephony/tests/BUILD.gn
+++ b/src/connectivity/telephony/tests/BUILD.gn
@@ -15,6 +15,7 @@
   public_deps = [
     ":devmgr-manifest",
     "component-integration:fake-at-driver-test",
+    "component-integration:fake-at-query",
     "component-integration:fake-qmi-query",
     "component-integration:snooper",
     "driver-integration:telephony-qmi-usb-integration-test",
@@ -37,6 +38,10 @@
       environments = basic_envs
     },
     {
+      name = "tel_fake_at_query"
+      environments = basic_envs
+    },
+    {
       name = "tel_fake_at_driver_test"
       environments = basic_envs
     },
diff --git a/src/connectivity/telephony/tests/component-integration/BUILD.gn b/src/connectivity/telephony/tests/component-integration/BUILD.gn
index a5564bd..47e19f4 100644
--- a/src/connectivity/telephony/tests/component-integration/BUILD.gn
+++ b/src/connectivity/telephony/tests/component-integration/BUILD.gn
@@ -12,6 +12,10 @@
   public_deps = [ "fake-qmi-query" ]
 }
 
+group("fake-at-query") {
+  testonly = true
+  public_deps = [ "fake-at-query" ]
+}
 group("snooper") {
   testonly = true
   public_deps = [ "snooper:multi-clients" ]
diff --git a/src/connectivity/telephony/tests/component-integration/fake-at-query/BUILD.gn b/src/connectivity/telephony/tests/component-integration/fake-at-query/BUILD.gn
new file mode 100644
index 0000000..2bd48f7
--- /dev/null
+++ b/src/connectivity/telephony/tests/component-integration/fake-at-query/BUILD.gn
@@ -0,0 +1,31 @@
+# Copyright 2019 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.
+
+import("//build/rust/rustc_test.gni")
+
+rustc_test("fake-at-query") {
+  name = "tel_fake_at_query"
+  edition = "2018"
+  deps = [
+    "//garnet/lib/rust/files_async",
+    "//sdk/fidl/fuchsia.telephony.ril:fuchsia.telephony.ril-rustc",
+    "//src/connectivity/telephony/lib/qmi",
+    "//src/connectivity/telephony/lib/tel-devmgr/fidl:devmgr-rustc",
+    "//src/connectivity/telephony/tests/tel-dev:tel_dev",
+    "//src/lib/fdio/rust:fdio",
+    "//src/lib/fidl/rust/fidl",
+    "//src/lib/fuchsia-async",
+    "//src/lib/fuchsia-component",
+    "//src/lib/storage/fuchsia-vfs-watcher",
+    "//src/lib/syslog/rust:syslog",
+    "//src/lib/zircon/rust:fuchsia-zircon",
+    "//third_party/rust_crates:anyhow",
+    "//third_party/rust_crates:futures",
+    "//third_party/rust_crates:pin-utils",
+    "//third_party/rust_crates:thiserror",
+    "//zircon/system/fidl/fuchsia-device:fuchsia-device-rustc",
+    "//zircon/system/fidl/fuchsia-io:fuchsia-io-rustc",
+  ]
+  non_rust_deps = [ "//zircon/public/lib/syslog" ]
+}
diff --git a/src/connectivity/telephony/tests/component-integration/fake-at-query/src/lib.rs b/src/connectivity/telephony/tests/component-integration/fake-at-query/src/lib.rs
new file mode 100644
index 0000000..1e9b8bf
--- /dev/null
+++ b/src/connectivity/telephony/tests/component-integration/fake-at-query/src/lib.rs
@@ -0,0 +1,87 @@
+// Copyright 2019 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 {
+    anyhow::{Context as _, Error},
+    fidl_fuchsia_telephony_ril::{RadioInterfaceLayerMarker, SetupMarker},
+    fuchsia_component::{
+        client::{launch, launcher},
+        fuchsia_single_component_package_url,
+    },
+    fuchsia_syslog::{self as syslog, macros::*},
+    futures::future::{join_all, Future},
+    futures::lock::Mutex,
+    qmi as tel_ctl, //Todo: rename qmi module
+    std::pin::Pin,
+    std::sync::Arc,
+    tel_dev::component_test::*,
+};
+
+// Send this command to attempt to make a call on the test driver and fail.
+const AT_CMD_REQ_ATD_STR: &str = "ATD\r";
+const AT_CMD_RESP_NO_CARRIER_STR: &str = "NO CARRIER\r";
+
+// Send this string to request the test driver sends back an invalid text string.
+const AT_CMD_REQ_INVALID_UNICODE_STR: &str = "INVALID UNICODE";
+
+const RIL_URL: &str = fuchsia_single_component_package_url!("ril-at");
+
+// TODO(kehrt) Split this into multiple tests.  Unfortunately, test setup and teardown multiple
+// times causes a variety of errors I don't understand yet.
+#[fuchsia_async::run_singlethreaded(test)]
+async fn at_one_query_test() -> Result<(), Error> {
+    syslog::init_with_tags(&["at-query-test"]).expect("Can't init logger");
+
+    //Setup
+    const TEL_PATH: &str = "class/at-transport";
+    let found_device =
+        get_fake_device_in_isolated_devmgr(TEL_PATH).await.expect("getting fake device");
+    let launcher = launcher().context("Failed to open launcher service")?;
+    let chan = tel_ctl::connect_transport_device(&found_device).await?;
+    let app =
+        launch(&launcher, RIL_URL.to_string(), None).context("Failed to launch ril-at service")?;
+    let ril_modem_setup = app.connect_to_service::<SetupMarker>()?;
+    ril_modem_setup.connect_transport(chan).await?.expect("make sure telephony svc is running");
+    let ril_modem = app.connect_to_service::<RadioInterfaceLayerMarker>()?;
+
+    // Test sending and receiving one message.
+    fx_log_err!("sending ATD");
+    let resp = ril_modem.raw_command(&AT_CMD_REQ_ATD_STR).await?.expect("error sending get info");
+    assert_eq!(resp, AT_CMD_RESP_NO_CARRIER_STR);
+    fx_log_err!("received and verified responses");
+
+    // Test sending a message that causes a parse error for the response.
+    fx_log_err!("sending a request which expects an error response");
+    let resp = ril_modem
+        .raw_command(&AT_CMD_REQ_INVALID_UNICODE_STR)
+        .await
+        .expect("error sending get info");
+    assert!(resp.is_err());
+    fx_log_err!("received and verified responses");
+
+    // Test interleaving a bunch of sends and receives.  let ril_modem_arc = Arc::new(Mutex::new(ril_modem));
+    let ril_modem_arc = Arc::new(Mutex::new(ril_modem));
+    let mut vec: Vec<Pin<Box<dyn Future<Output = (i32, String)>>>> = Vec::new();
+    for x in 0..100 {
+        let ril_modem_arc = ril_modem_arc.clone();
+        vec.push(Box::pin(async move {
+            let send_string = format!("RACE{:}", x);
+            let ril_modem_arc = ril_modem_arc.lock().await;
+            let recv_result = ril_modem_arc.raw_command(&send_string).await;
+            (x, recv_result.unwrap().unwrap())
+        }))
+    }
+
+    let joined = join_all(vec).await;
+
+    for (x, recv_result) in joined.into_iter() {
+        let recv_string = format!("ECAR{:}", x);
+        assert!(recv_string == recv_result);
+    }
+    // Tear down
+    unbind_fake_device(&found_device)?;
+    fx_log_err!("unbinded device");
+    validate_removal_of_fake_device(TEL_PATH).await.expect("validate removal of device");
+    Ok(())
+}
diff --git a/src/connectivity/telephony/tests/component-integration/fake-qmi-query/src/lib.rs b/src/connectivity/telephony/tests/component-integration/fake-qmi-query/src/lib.rs
index 3dfc73f..04bb78b 100644
--- a/src/connectivity/telephony/tests/component-integration/fake-qmi-query/src/lib.rs
+++ b/src/connectivity/telephony/tests/component-integration/fake-qmi-query/src/lib.rs
@@ -4,7 +4,6 @@
 
 use {
     anyhow::{Context as _, Error},
-    fidl_fuchsia_io,
     fidl_fuchsia_telephony_ril::{RadioInterfaceLayerMarker, SetupMarker},
     fuchsia_component::{
         client::{launch, launcher},
@@ -12,8 +11,7 @@
     },
     fuchsia_syslog::{self as syslog, macros::*},
     qmi,
-    std::path::Path,
-    tel_dev::{component_test::*, isolated_devmgr},
+    tel_dev::component_test::*,
 };
 
 const RIL_URL: &str = fuchsia_single_component_package_url!("ril-qmi");
@@ -23,17 +21,8 @@
 async fn qmi_query_test() -> Result<(), Error> {
     syslog::init_with_tags(&["qmi-query-test"]).expect("Can't init logger");
     const TEL_PATH: &str = "class/qmi-transport";
-    let tel_dir =
-        isolated_devmgr::open_dir_in_isolated_devmgr(TEL_PATH).expect("opening qmi-transport dir");
-    let directory_proxy = fidl_fuchsia_io::DirectoryProxy::new(
-        fuchsia_async::Channel::from_channel(fdio::clone_channel(&tel_dir)?)?,
-    );
-    let tel_devices = files_async::readdir(&directory_proxy).await?;
-    let last_device: &files_async::DirEntry = tel_devices.last().expect("no device found");
-    let found_device_path = Box::new(Path::new(TEL_PATH).join(last_device.name.clone()));
-    assert_eq!(tel_devices.len(), 1);
-    fx_log_info!("connecting to {:?}", &*found_device_path);
-    let found_device = isolated_devmgr::open_file_in_isolated_devmgr(*found_device_path).unwrap();
+    let found_device =
+        get_fake_device_in_isolated_devmgr(TEL_PATH).await.expect("getting fake device");
     let launcher = launcher().context("Failed to open launcher service")?;
     let chan = qmi::connect_transport_device(&found_device).await?;
     let app =
@@ -41,6 +30,7 @@
     let ril_modem_setup = app.connect_to_service::<SetupMarker>()?;
     ril_modem_setup.connect_transport(chan).await?.expect("make sure telephony svc is running");
     let ril_modem = app.connect_to_service::<RadioInterfaceLayerMarker>()?;
+
     fx_log_info!("sending a IMEI request");
     let imei = ril_modem.get_device_identity().await?.expect("error sending IMEI request");
     assert_eq!(imei, "359260080168351");
diff --git a/src/connectivity/telephony/tests/fake-drivers/at-fake-transport/fake-device.cc b/src/connectivity/telephony/tests/fake-drivers/at-fake-transport/fake-device.cc
index 6f67d39..d3f8e1ee 100644
--- a/src/connectivity/telephony/tests/fake-drivers/at-fake-transport/fake-device.cc
+++ b/src/connectivity/telephony/tests/fake-drivers/at-fake-transport/fake-device.cc
@@ -13,6 +13,7 @@
 #include <cstdio>
 #include <future>
 #include <string>
+
 #include <ddktl/fidl.h>
 
 namespace fidl_tel_snoop = ::llcpp::fuchsia::telephony::snoop;
@@ -24,6 +25,14 @@
 static const std::string kAtCmdRespManuId = "Sierra Wireless Incorporated\r\rOK\r";
 static const std::string kAtCmdRespErr = "ERROR\r";
 
+static const size_t kRaceDetectionPrefixSize = 4;
+static const std::string kRaceDetectionRequestPrefix = "RACE";
+static const std::string kRaceDetectionResponsePrefix = "ECAR";
+
+static const std::string kInvalidUnicodeRequest = "INVALID UNICODE";
+static const size_t kInvalidUnicodeResponseSize = 2;
+static const char* kInvalidUnicodeResponse = "\x80\x81";
+
 constexpr uint32_t kTelCtrlPlanePktMax = 2048;
 
 AtDevice::AtDevice(zx_device_t* device) : Device(device) {}
@@ -52,7 +61,7 @@
 }
 
 void AtDevice::SnoopCtrlMsg(uint8_t* snoop_data, uint32_t snoop_data_len,
-                             fidl_tel_snoop::Direction direction) {
+                            fidl_tel_snoop::Direction direction) {
   if (GetCtrlSnoopChannel()) {
     fidl_tel_snoop::Message snoop_msg;
     fidl_tel_snoop::QmiMessage msg;
@@ -64,26 +73,44 @@
     memcpy(msg.opaque_bytes.data_, snoop_data, current_length);
     snoop_msg.set_qmi_message(&msg);
     zxlogf(INFO, "at-fake-transport: snoop msg %u %u %u %u sent\n", msg.opaque_bytes.data_[0],
-           msg.opaque_bytes.data_[1], msg.opaque_bytes.data_[2],
-           msg.opaque_bytes.data_[3]);
+           msg.opaque_bytes.data_[1], msg.opaque_bytes.data_[2], msg.opaque_bytes.data_[3]);
     fidl_tel_snoop::Publisher::Call::SendMessage(zx::unowned_channel(GetCtrlSnoopChannel().get()),
                                                  std::move(snoop_msg));
   }
 }
 
 void AtDevice::ReplyCtrlMsg(uint8_t* req, uint32_t req_size, uint8_t* resp, uint32_t resp_size) {
-  zxlogf(INFO, "at-fake-driver: req %u %u %u %u with len %u\n", req[0], req[1], req[2], req[3], req_size);
+  zxlogf(INFO, "at-fake-driver: req %u %u %u %u with len %u\n", req[0], req[1], req[2], req[3],
+         req_size);
   if (0 == memcmp(req, kAtCmdReqAtdStr.c_str(), kAtCmdReqAtdStr.size())) {
     resp_size = std::min(kAtCmdRespNoCarrier.size(), static_cast<std::size_t>(resp_size));
     memcpy(resp, kAtCmdRespNoCarrier.c_str(), resp_size);
-    zxlogf(INFO, "at-fake-driver: resp %u %u %u %u with len %u\n", resp[0], resp[1], resp[2], resp[3], resp_size);
+    zxlogf(INFO, "at-fake-driver: resp %u %u %u %u with len %u\n", resp[0], resp[1], resp[2],
+           resp[3], resp_size);
     sent_fake_at_msg(GetCtrlChannel(), resp, resp_size);
     SnoopCtrlMsg(resp, resp_size, fidl_tel_snoop::Direction::FROM_MODEM);
+
   } else if (0 == memcmp(req, kAtCmdReqAtCgmi.c_str(), kAtCmdReqAtCgmi.size())) {
     resp_size = std::min(kAtCmdRespManuId.size(), static_cast<std::size_t>(resp_size));
     memcpy(resp, kAtCmdRespManuId.c_str(), resp_size);
     sent_fake_at_msg(GetCtrlChannel(), resp, resp_size);
     SnoopCtrlMsg(resp, resp_size, fidl_tel_snoop::Direction::FROM_MODEM);
+
+  } else if (0 == memcmp(req, kInvalidUnicodeRequest.c_str(), kInvalidUnicodeRequest.size())) {
+    resp_size = std::min(kInvalidUnicodeResponseSize, static_cast<std::size_t>(resp_size));
+    memcpy(resp, kInvalidUnicodeResponse, resp_size);
+    sent_fake_at_msg(GetCtrlChannel(), resp, resp_size);
+    SnoopCtrlMsg(resp, resp_size, fidl_tel_snoop::Direction::FROM_MODEM);
+
+  } else if (req_size >= kRaceDetectionPrefixSize &&
+             0 == memcmp(req, kRaceDetectionRequestPrefix.c_str(), kRaceDetectionPrefixSize)) {
+    resp_size = std::min(resp_size, req_size);
+    memcpy(resp, kRaceDetectionResponsePrefix.c_str(), kRaceDetectionPrefixSize);
+    memcpy(resp + kRaceDetectionPrefixSize, req + kRaceDetectionPrefixSize,
+           req_size - kRaceDetectionPrefixSize);
+    sent_fake_at_msg(GetCtrlChannel(), resp, resp_size);
+    SnoopCtrlMsg(resp, resp_size, fidl_tel_snoop::Direction::FROM_MODEM);
+
   } else {
     zxlogf(ERROR, "at-fake-driver: unexpected at msg received\n");
     resp_size = std::min(kAtCmdRespErr.size(), static_cast<std::size_t>(resp_size));
@@ -149,8 +176,7 @@
   // create a port to watch at messages
   zx_status_t status = zx::port::create(0, &GetCtrlChannelPort());
   if (status != ZX_OK) {
-    zxlogf(ERROR, "at-fake-transport: failed to create a port: %s\n",
-           zx_status_get_string(status));
+    zxlogf(ERROR, "at-fake-transport: failed to create a port: %s\n", zx_status_get_string(status));
     return status;
   }
 
diff --git a/src/connectivity/telephony/tests/meta/tel_fake_at_query.cmx b/src/connectivity/telephony/tests/meta/tel_fake_at_query.cmx
new file mode 100644
index 0000000..a1e54ea
--- /dev/null
+++ b/src/connectivity/telephony/tests/meta/tel_fake_at_query.cmx
@@ -0,0 +1,32 @@
+{
+    "facets": {
+        "fuchsia.test": {
+            "injected-services": {
+                "fuchsia.tel.devmgr.IsolatedDevmgr": [
+                    "fuchsia-pkg://fuchsia.com/tel_devmgr_at_component_test#meta/tel_devmgr_at_component_test.cmx"
+                ]
+            }
+        }
+    },
+    "program": {
+        "binary": "test/tel_fake_at_query"
+    },
+    "sandbox": {
+        "boot": [
+            "bin",
+            "driver",
+            "lib"
+        ],
+        "dev": [
+            "class/at-transport",
+            "test/test"
+        ],
+        "services": [
+            "fuchsia.sys.Launcher",
+            "fuchsia.tel.devmgr.IsolatedDevmgr"
+        ],
+        "system": [
+            "driver/at-fake-transport.so"
+        ]
+    }
+}