diff --git a/src/viam/api/CMakeLists.txt b/src/viam/api/CMakeLists.txt
index 28ac60d3a..3bdfbf61f 100644
--- a/src/viam/api/CMakeLists.txt
+++ b/src/viam/api/CMakeLists.txt
@@ -192,6 +192,10 @@ if (VIAMCPPSDK_USE_DYNAMIC_PROTOS)
     ${PROTO_GEN_DIR}/robot/v1/robot.grpc.pb.h
     ${PROTO_GEN_DIR}/robot/v1/robot.pb.cc
     ${PROTO_GEN_DIR}/robot/v1/robot.pb.h
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.grpc.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.grpc.pb.h
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.pb.h
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.grpc.pb.cc
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.grpc.pb.h
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.pb.cc
@@ -287,6 +291,8 @@ target_sources(viamapi
     ${PROTO_GEN_DIR}/module/v1/module.pb.cc
     ${PROTO_GEN_DIR}/robot/v1/robot.grpc.pb.cc
     ${PROTO_GEN_DIR}/robot/v1/robot.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.grpc.pb.cc
+    ${PROTO_GEN_DIR}/service/generic/v1/generic.pb.cc
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.grpc.pb.cc
     ${PROTO_GEN_DIR}/service/mlmodel/v1/mlmodel.pb.cc
     ${PROTO_GEN_DIR}/service/motion/v1/motion.grpc.pb.cc
@@ -332,6 +338,8 @@ target_sources(viamapi
       ${PROTO_GEN_DIR}/../../viam/api/robot/v1/robot.grpc.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/robot/v1/robot.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/tagger/v1/tagger.grpc.pb.h
+      ${PROTO_GEN_DIR}/../../viam/api/service/generic/v1/generic.grpc.pb.h
+      ${PROTO_GEN_DIR}/../../viam/api/service/generic/v1/generic.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/service/mlmodel/v1/mlmodel.grpc.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/service/mlmodel/v1/mlmodel.pb.h
       ${PROTO_GEN_DIR}/../../viam/api/service/motion/v1/motion.grpc.pb.h
diff --git a/src/viam/examples/dial/example_dial.cpp b/src/viam/examples/dial/example_dial.cpp
index 81c0d4627..84770ad0a 100644
--- a/src/viam/examples/dial/example_dial.cpp
+++ b/src/viam/examples/dial/example_dial.cpp
@@ -63,9 +63,9 @@ int main() {
     }
 
     // ensure we can create clients to the robot
-    auto gc = robot->resource_by_name<Generic>("generic1");
+    auto gc = robot->resource_by_name<GenericComponent>("generic1");
     if (gc) {
-        std::cout << "got generic client named " << gc->name() << std::endl;
+        std::cout << "got generic component client named " << gc->name() << std::endl;
     }
 
     return EXIT_SUCCESS;
diff --git a/src/viam/examples/modules/simple/main.cpp b/src/viam/examples/modules/simple/main.cpp
index fc1f8c5d4..7e74d19eb 100644
--- a/src/viam/examples/modules/simple/main.cpp
+++ b/src/viam/examples/modules/simple/main.cpp
@@ -8,11 +8,9 @@
 #include <grpcpp/server_context.h>
 
 #include <viam/api/common/v1/common.grpc.pb.h>
-#include <viam/api/component/generic/v1/generic.grpc.pb.h>
 #include <viam/api/robot/v1/robot.pb.h>
+#include <viam/api/service/generic/v1/generic.grpc.pb.h>
 
-#include <viam/sdk/components/component.hpp>
-#include <viam/sdk/components/generic/generic.hpp>
 #include <viam/sdk/config/resource.hpp>
 #include <viam/sdk/module/module.hpp>
 #include <viam/sdk/module/service.hpp>
@@ -20,13 +18,15 @@
 #include <viam/sdk/resource/resource.hpp>
 #include <viam/sdk/rpc/dial.hpp>
 #include <viam/sdk/rpc/server.hpp>
+#include <viam/sdk/services/generic/generic.hpp>
+#include <viam/sdk/services/service.hpp>
 
 using namespace viam::sdk;
 
 // Printer is a modular resource that can print a to_print value to STDOUT when
 // a DoCommand request is received or when reconfiguring. The to_print value
 // must be provided as an attribute in the config.
-class Printer : public Generic {
+class Printer : public GenericService {
    public:
     void reconfigure(Dependencies deps, ResourceConfig cfg) {
         std::cout << "Printer " << Resource::name() << " is reconfiguring" << std::endl;
@@ -37,7 +37,7 @@ class Printer : public Generic {
         std::cout << "Printer " << Resource::name() << " will now print " << to_print_ << std::endl;
     }
 
-    Printer(Dependencies deps, ResourceConfig cfg) : Generic(cfg.name()) {
+    Printer(Dependencies deps, ResourceConfig cfg) : GenericService(cfg.name()) {
         std::cout << "Creating Printer " + Resource::name() << std::endl;
         to_print_ = find_to_print(cfg);
         std::cout << "Printer " << Resource::name() << " will print " << to_print_ << std::endl;
@@ -49,10 +49,6 @@ class Printer : public Generic {
         return command;
     }
 
-    std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) {
-        return std::vector<GeometryConfig>();
-    }
-
     static std::string find_to_print(ResourceConfig cfg) {
         auto& printer_name = cfg.name();
         auto to_print = cfg.attributes()->find("to_print");
@@ -77,7 +73,7 @@ class Printer : public Generic {
 };
 
 int main(int argc, char** argv) {
-    API generic = API::get<Generic>();
+    API generic = API::get<GenericService>();
     Model m("viam", "generic", "printer");
 
     std::shared_ptr<ModelRegistration> mr = std::make_shared<ModelRegistration>(
diff --git a/src/viam/sdk/CMakeLists.txt b/src/viam/sdk/CMakeLists.txt
index 77bb40201..5a5cda6c8 100644
--- a/src/viam/sdk/CMakeLists.txt
+++ b/src/viam/sdk/CMakeLists.txt
@@ -96,6 +96,9 @@ target_sources(viamsdk
     robot/service.cpp
     rpc/dial.cpp
     rpc/server.cpp
+    services/generic/client.cpp
+    services/generic/generic.cpp
+    services/generic/server.cpp
     services/mlmodel/client.cpp
     services/mlmodel/mlmodel.cpp
     services/mlmodel/private/proto.cpp
@@ -165,6 +168,9 @@ target_sources(viamsdk
       ../../viam/sdk/robot/service.hpp
       ../../viam/sdk/rpc/dial.hpp
       ../../viam/sdk/rpc/server.hpp
+      ../../viam/sdk/services/generic/client.hpp
+      ../../viam/sdk/services/generic/generic.hpp
+      ../../viam/sdk/services/generic/server.hpp
       ../../viam/sdk/services/mlmodel/client.hpp
       ../../viam/sdk/services/mlmodel/mlmodel.hpp
       ../../viam/sdk/services/mlmodel/server.hpp
diff --git a/src/viam/sdk/components/generic/client.cpp b/src/viam/sdk/components/generic/client.cpp
index cca6b4d47..10baf5d71 100644
--- a/src/viam/sdk/components/generic/client.cpp
+++ b/src/viam/sdk/components/generic/client.cpp
@@ -14,18 +14,19 @@
 namespace viam {
 namespace sdk {
 
-GenericClient::GenericClient(std::string name, std::shared_ptr<grpc::Channel> channel)
-    : Generic(std::move(name)),
+GenericComponentClient::GenericComponentClient(std::string name,
+                                               std::shared_ptr<grpc::Channel> channel)
+    : GenericComponent(std::move(name)),
       stub_(viam::component::generic::v1::GenericService::NewStub(channel)),
       channel_(std::move(channel)){};
 
-AttributeMap GenericClient::do_command(AttributeMap command) {
+AttributeMap GenericComponentClient::do_command(AttributeMap command) {
     return make_client_helper(this, *stub_, &StubType::DoCommand)
         .with([&](auto& request) { *request.mutable_command() = map_to_struct(command); })
         .invoke([](auto& response) { return struct_to_map(response.result()); });
 }
 
-std::vector<GeometryConfig> GenericClient::get_geometries(const AttributeMap& extra) {
+std::vector<GeometryConfig> GenericComponentClient::get_geometries(const AttributeMap& extra) {
     return make_client_helper(this, *stub_, &StubType::GetGeometries)
         .with(extra)
         .invoke([](auto& response) { return GeometryConfig::from_proto(response); });
diff --git a/src/viam/sdk/components/generic/client.hpp b/src/viam/sdk/components/generic/client.hpp
index 3584eb8c5..97a4b0168 100644
--- a/src/viam/sdk/components/generic/client.hpp
+++ b/src/viam/sdk/components/generic/client.hpp
@@ -1,6 +1,6 @@
 /// @file components/generic/client.hpp
 ///
-/// @brief Implements a gRPC client for the `Generic` component.
+/// @brief Implements a gRPC client for the `GenericComponent`.
 #pragma once
 
 #include <grpcpp/channel.h>
@@ -13,12 +13,12 @@
 namespace viam {
 namespace sdk {
 
-/// @class GenericClient
-/// @brief gRPC client implementation of a `Generic` component.
-/// @ingroup Generic
-class GenericClient : public Generic {
+/// @class GenericComponentClient
+/// @brief gRPC client implementation of a `GenericComponent`.
+/// @ingroup GenericComponent
+class GenericComponentClient : public GenericComponent {
    public:
-    GenericClient(std::string name, std::shared_ptr<grpc::Channel> channel);
+    GenericComponentClient(std::string name, std::shared_ptr<grpc::Channel> channel);
     AttributeMap do_command(AttributeMap command) override;
     std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) override;
 
@@ -26,9 +26,10 @@ class GenericClient : public Generic {
     // This constructor leaves the `channel_` as a nullptr. This is useful for testing
     // purposes, but renders it unusable for production use. Care should be taken to
     // avoid use of this constructor outside of tests.
-    GenericClient(std::string name,
-                  std::unique_ptr<viam::component::generic::v1::GenericService::StubInterface> stub)
-        : Generic(std::move(name)), stub_(std::move(stub)){};
+    GenericComponentClient(
+        std::string name,
+        std::unique_ptr<viam::component::generic::v1::GenericService::StubInterface> stub)
+        : GenericComponent(std::move(name)), stub_(std::move(stub)){};
 
    private:
     using StubType = viam::component::generic::v1::GenericService::StubInterface;
diff --git a/src/viam/sdk/components/generic/generic.cpp b/src/viam/sdk/components/generic/generic.cpp
index 727bfd9c2..4e8ebefe4 100644
--- a/src/viam/sdk/components/generic/generic.cpp
+++ b/src/viam/sdk/components/generic/generic.cpp
@@ -15,45 +15,47 @@
 namespace viam {
 namespace sdk {
 
-GenericRegistration::GenericRegistration(
+GenericComponentRegistration::GenericComponentRegistration(
     const google::protobuf::ServiceDescriptor* service_descriptor)
     : ResourceRegistration(service_descriptor){};
 
-std::shared_ptr<ResourceServer> GenericRegistration::create_resource_server(
+std::shared_ptr<ResourceServer> GenericComponentRegistration::create_resource_server(
     std::shared_ptr<ResourceManager> manager, Server& server) {
-    auto gs = std::make_shared<GenericServer>(std::move(manager));
+    auto gs = std::make_shared<GenericComponentServer>(std::move(manager));
     server.register_service(gs.get());
     return gs;
 };
 
-std::shared_ptr<Resource> GenericRegistration::create_rpc_client(
+std::shared_ptr<Resource> GenericComponentRegistration::create_rpc_client(
     std::string name, std::shared_ptr<grpc::Channel> chan) {
-    return std::make_shared<GenericClient>(std::move(name), std::move(chan));
+    return std::make_shared<GenericComponentClient>(std::move(name), std::move(chan));
 };
 
-std::shared_ptr<ResourceRegistration> Generic::resource_registration() {
+std::shared_ptr<ResourceRegistration> GenericComponent::resource_registration() {
     const google::protobuf::DescriptorPool* p = google::protobuf::DescriptorPool::generated_pool();
     const google::protobuf::ServiceDescriptor* sd =
         p->FindServiceByName(viam::component::generic::v1::GenericService::service_full_name());
     if (!sd) {
-        throw std::runtime_error("Unable to get service descriptor for the generic service");
+        throw std::runtime_error(
+            "Unable to get service descriptor for the generic component service");
     }
-    return std::make_shared<GenericRegistration>(sd);
+    return std::make_shared<GenericComponentRegistration>(sd);
 }
 
-API Generic::api() const {
-    return API::get<Generic>();
+API GenericComponent::api() const {
+    return API::get<GenericComponent>();
 }
 
-API API::traits<Generic>::api() {
+API API::traits<GenericComponent>::api() {
     return {kRDK, kComponent, "generic"};
 }
 
-Generic::Generic(std::string name) : Component(std::move(name)){};
+GenericComponent::GenericComponent(std::string name) : Component(std::move(name)){};
 
 namespace {
 bool init() {
-    Registry::register_resource(API::get<Generic>(), Generic::resource_registration());
+    Registry::register_resource(API::get<GenericComponent>(),
+                                GenericComponent::resource_registration());
     return true;
 };
 
diff --git a/src/viam/sdk/components/generic/generic.hpp b/src/viam/sdk/components/generic/generic.hpp
index 3a31e7b48..6e0a08fb7 100644
--- a/src/viam/sdk/components/generic/generic.hpp
+++ b/src/viam/sdk/components/generic/generic.hpp
@@ -1,6 +1,7 @@
 /// @file generic/generic.hpp
 ///
-/// @brief Defines `Generic` subtype and component class capable of executing arbitrary commands.
+/// @brief Defines `GenericComponent` subtype and component class capable of executing arbitrary
+/// commands.
 #pragma once
 
 #include <google/protobuf/descriptor.h>
@@ -14,34 +15,33 @@
 namespace viam {
 namespace sdk {
 
-// TODO(RSDK-1742): one class per header
-/// @defgroup Generic Classes related to the Generic component.
+// TODO(RSDK-3030): one class per header
+/// @defgroup GenericComponent Classes related to the generic component.
 
-/// @class GenericRegistration
-/// @brief Defines a `ResourceRegistration` for the `Generic` component.
-/// @ingroup Generic
-class GenericRegistration : public ResourceRegistration {
+/// @class GenericComponentRegistration
+/// @brief Defines a `ResourceRegistration` for the generic component.
+/// @ingroup GenericComponent
+class GenericComponentRegistration : public ResourceRegistration {
    public:
-    explicit GenericRegistration(const google::protobuf::ServiceDescriptor* service_descriptor);
+    explicit GenericComponentRegistration(
+        const google::protobuf::ServiceDescriptor* service_descriptor);
     std::shared_ptr<ResourceServer> create_resource_server(std::shared_ptr<ResourceManager> manager,
                                                            Server& server) override;
     std::shared_ptr<Resource> create_rpc_client(std::string name,
                                                 std::shared_ptr<grpc::Channel> chan) override;
 };
 
-/// @class Generic generic.hpp "components/generic/generic.hpp"
-/// @brief A `Generic` represents any component that can execute arbitrary commands.
-/// @ingroup Generic
+/// @class GenericComponent generic.hpp "components/generic/generic.hpp"
+/// @brief A `GenericComponent` represents any component that can execute arbitrary commands.
+/// @ingroup GenericComponent
 ///
 /// This acts as an abstract base class to be inherited from by any drivers representing
 /// specific generic implementations. This class cannot be used on its own.
-class Generic : public Component {
+class GenericComponent : public Component {
    public:
-    /// @brief Creates a `ResourceRegistration` for the `Generic` component.
+    /// @brief Creates a `ResourceRegistration` for `GenericComponent`.
     static std::shared_ptr<ResourceRegistration> resource_registration();
 
-    /// @brief Creates a `Generic` `API`.
-
     /// @brief Send/receive arbitrary commands to the resource.
     /// @param command the command to execute.
     /// @return The result of the executed command.
@@ -55,14 +55,15 @@ class Generic : public Component {
 
     virtual std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) = 0;
 
+    /// @brief Creates a `GenericComponent` `API`.
     API api() const override;
 
    protected:
-    explicit Generic(std::string name);
+    explicit GenericComponent(std::string name);
 };
 
 template <>
-struct API::traits<Generic> {
+struct API::traits<GenericComponent> {
     static API api();
 };
 
diff --git a/src/viam/sdk/components/generic/server.cpp b/src/viam/sdk/components/generic/server.cpp
index 9be5ea151..95cfedeb7 100644
--- a/src/viam/sdk/components/generic/server.cpp
+++ b/src/viam/sdk/components/generic/server.cpp
@@ -7,24 +7,25 @@
 namespace viam {
 namespace sdk {
 
-GenericServer::GenericServer(std::shared_ptr<ResourceManager> manager)
+GenericComponentServer::GenericComponentServer(std::shared_ptr<ResourceManager> manager)
     : ResourceServer(std::move(manager)){};
 
-::grpc::Status GenericServer::DoCommand(::grpc::ServerContext* context,
-                                        const ::viam::common::v1::DoCommandRequest* request,
-                                        ::viam::common::v1::DoCommandResponse* response) noexcept {
-    return make_service_helper<Generic>(
-        "GenericServer::DoCommand", this, request)([&](auto& helper, auto& generic) {
+::grpc::Status GenericComponentServer::DoCommand(
+    ::grpc::ServerContext* context,
+    const ::viam::common::v1::DoCommandRequest* request,
+    ::viam::common::v1::DoCommandResponse* response) noexcept {
+    return make_service_helper<GenericComponent>(
+        "GenericComponentServer::DoCommand", this, request)([&](auto& helper, auto& generic) {
         const AttributeMap result = generic->do_command(struct_to_map(request->command()));
         *response->mutable_result() = map_to_struct(result);
     });
 }
-::grpc::Status GenericServer::GetGeometries(
+::grpc::Status GenericComponentServer::GetGeometries(
     ::grpc::ServerContext* context,
     const ::viam::common::v1::GetGeometriesRequest* request,
     ::viam::common::v1::GetGeometriesResponse* response) noexcept {
-    return make_service_helper<Generic>(
-        "GenericServer::GetGeometries", this, request)([&](auto& helper, auto& generic) {
+    return make_service_helper<GenericComponent>(
+        "GenericComponentServer::GetGeometries", this, request)([&](auto& helper, auto& generic) {
         const std::vector<GeometryConfig> geometries = generic->get_geometries(helper.getExtra());
         for (const auto& geometry : geometries) {
             *response->mutable_geometries()->Add() = geometry.to_proto();
diff --git a/src/viam/sdk/components/generic/server.hpp b/src/viam/sdk/components/generic/server.hpp
index e8ddf2f3f..d1061b9c0 100644
--- a/src/viam/sdk/components/generic/server.hpp
+++ b/src/viam/sdk/components/generic/server.hpp
@@ -1,6 +1,6 @@
 /// @file components/generic/server.hpp
 ///
-/// @brief Implements a gRPC server for the `Generic` component.
+/// @brief Implements a gRPC server for the `GenericComponent`.
 #pragma once
 
 #include <viam/api/common/v1/common.grpc.pb.h>
@@ -12,13 +12,13 @@
 namespace viam {
 namespace sdk {
 
-/// @class GenericServer
-/// @brief gRPC server implementation of a `Generic` component.
-/// @ingroup Generic
-class GenericServer : public ResourceServer,
-                      public viam::component::generic::v1::GenericService::Service {
+/// @class GenericComponentServer
+/// @brief gRPC server implementation of a `GenericComponent`.
+/// @ingroup GenericComponent
+class GenericComponentServer : public ResourceServer,
+                               public viam::component::generic::v1::GenericService::Service {
    public:
-    explicit GenericServer(std::shared_ptr<ResourceManager> manager);
+    explicit GenericComponentServer(std::shared_ptr<ResourceManager> manager);
 
     ::grpc::Status DoCommand(::grpc::ServerContext* context,
                              const ::viam::common::v1::DoCommandRequest* request,
diff --git a/src/viam/sdk/services/generic/client.cpp b/src/viam/sdk/services/generic/client.cpp
new file mode 100644
index 000000000..493b76109
--- /dev/null
+++ b/src/viam/sdk/services/generic/client.cpp
@@ -0,0 +1,29 @@
+#include <viam/sdk/services/generic/client.hpp>
+
+#include <utility>
+
+#include <viam/api/common/v1/common.pb.h>
+#include <viam/api/service/generic/v1/generic.grpc.pb.h>
+
+#include <viam/sdk/common/client_helper.hpp>
+#include <viam/sdk/common/proto_type.hpp>
+#include <viam/sdk/common/utils.hpp>
+#include <viam/sdk/config/resource.hpp>
+#include <viam/sdk/robot/client.hpp>
+
+namespace viam {
+namespace sdk {
+
+GenericServiceClient::GenericServiceClient(std::string name, std::shared_ptr<grpc::Channel> channel)
+    : GenericService(std::move(name)),
+      stub_(viam::service::generic::v1::GenericService::NewStub(channel)),
+      channel_(std::move(channel)){};
+
+AttributeMap GenericServiceClient::do_command(AttributeMap command) {
+    return make_client_helper(this, *stub_, &StubType::DoCommand)
+        .with([&](auto& request) { *request.mutable_command() = map_to_struct(command); })
+        .invoke([](auto& response) { return struct_to_map(response.result()); });
+}
+
+}  // namespace sdk
+}  // namespace viam
diff --git a/src/viam/sdk/services/generic/client.hpp b/src/viam/sdk/services/generic/client.hpp
new file mode 100644
index 000000000..4a8bf8e30
--- /dev/null
+++ b/src/viam/sdk/services/generic/client.hpp
@@ -0,0 +1,40 @@
+/// @file services/generic/client.hpp
+///
+/// @brief Implements a gRPC client for the `GenericService`.
+#pragma once
+
+#include <grpcpp/channel.h>
+
+#include <viam/api/service/generic/v1/generic.grpc.pb.h>
+
+#include <viam/sdk/robot/client.hpp>
+#include <viam/sdk/services/generic/generic.hpp>
+
+namespace viam {
+namespace sdk {
+
+/// @class GenericServiceClient
+/// @brief gRPC client implementation of a `GenericService`.
+/// @ingroup GenericService
+class GenericServiceClient : public GenericService {
+   public:
+    GenericServiceClient(std::string name, std::shared_ptr<grpc::Channel> channel);
+    AttributeMap do_command(AttributeMap command) override;
+
+   protected:
+    // This constructor leaves the `channel_` as a nullptr. This is useful for testing
+    // purposes, but renders it unusable for production use. Care should be taken to
+    // avoid use of this constructor outside of tests.
+    GenericServiceClient(
+        std::string name,
+        std::unique_ptr<viam::service::generic::v1::GenericService::StubInterface> stub)
+        : GenericService(std::move(name)), stub_(std::move(stub)){};
+
+   private:
+    using StubType = viam::service::generic::v1::GenericService::StubInterface;
+    std::unique_ptr<StubType> stub_;
+    std::shared_ptr<grpc::Channel> channel_;
+};
+
+}  // namespace sdk
+}  // namespace viam
diff --git a/src/viam/sdk/services/generic/generic.cpp b/src/viam/sdk/services/generic/generic.cpp
new file mode 100644
index 000000000..2423ee84e
--- /dev/null
+++ b/src/viam/sdk/services/generic/generic.cpp
@@ -0,0 +1,66 @@
+#include <viam/sdk/services/generic/generic.hpp>
+
+#include <stdexcept>
+
+#include <google/protobuf/descriptor.h>
+
+#include <viam/api/service/generic/v1/generic.grpc.pb.h>
+
+#include <viam/sdk/common/utils.hpp>
+#include <viam/sdk/registry/registry.hpp>
+#include <viam/sdk/resource/resource.hpp>
+#include <viam/sdk/services/generic/client.hpp>
+#include <viam/sdk/services/generic/server.hpp>
+
+namespace viam {
+namespace sdk {
+
+GenericServiceRegistration::GenericServiceRegistration(
+    const google::protobuf::ServiceDescriptor* service_descriptor)
+    : ResourceRegistration(service_descriptor){};
+
+std::shared_ptr<ResourceServer> GenericServiceRegistration::create_resource_server(
+    std::shared_ptr<ResourceManager> manager, Server& server) {
+    auto gs = std::make_shared<GenericServiceServer>(std::move(manager));
+    server.register_service(gs.get());
+    return gs;
+};
+
+std::shared_ptr<Resource> GenericServiceRegistration::create_rpc_client(
+    std::string name, std::shared_ptr<grpc::Channel> chan) {
+    return std::make_shared<GenericServiceClient>(std::move(name), std::move(chan));
+};
+
+std::shared_ptr<ResourceRegistration> GenericService::resource_registration() {
+    const google::protobuf::DescriptorPool* p = google::protobuf::DescriptorPool::generated_pool();
+    const google::protobuf::ServiceDescriptor* sd =
+        p->FindServiceByName(viam::component::generic::v1::GenericService::service_full_name());
+    if (!sd) {
+        throw std::runtime_error("Unable to get service descriptor for the generic service");
+    }
+    return std::make_shared<GenericServiceRegistration>(sd);
+}
+
+API GenericService::api() const {
+    return API::get<GenericService>();
+}
+
+API API::traits<GenericService>::api() {
+    return {kRDK, kService, "generic"};
+}
+
+GenericService::GenericService(std::string name) : Service(std::move(name)){};
+
+namespace {
+bool init() {
+    Registry::register_resource(API::get<GenericService>(),
+                                GenericService::resource_registration());
+    return true;
+};
+
+// NOLINTNEXTLINE
+const bool inited = init();
+}  // namespace
+
+}  // namespace sdk
+}  // namespace viam
diff --git a/src/viam/sdk/services/generic/generic.hpp b/src/viam/sdk/services/generic/generic.hpp
new file mode 100644
index 000000000..f6ab0218e
--- /dev/null
+++ b/src/viam/sdk/services/generic/generic.hpp
@@ -0,0 +1,64 @@
+/// @file generic/generic.hpp
+///
+/// @brief Defines `GenericService` subtype and service class capable of
+/// executing arbitrary commands.
+#pragma once
+
+#include <google/protobuf/descriptor.h>
+
+#include <viam/sdk/common/proto_type.hpp>
+#include <viam/sdk/common/utils.hpp>
+#include <viam/sdk/config/resource.hpp>
+#include <viam/sdk/registry/registry.hpp>
+#include <viam/sdk/resource/resource_manager.hpp>
+#include <viam/sdk/services/service.hpp>
+
+namespace viam {
+namespace sdk {
+
+// TODO(RSDK-3030): one class per header
+/// @defgroup GenericService Classes related to the generic service.
+
+/// @class GenericServiceRegistration
+/// @brief Defines a `ResourceRegistration` for the `GenericService`.
+/// @ingroup GenericService
+class GenericServiceRegistration : public ResourceRegistration {
+   public:
+    explicit GenericServiceRegistration(
+        const google::protobuf::ServiceDescriptor* service_descriptor);
+    std::shared_ptr<ResourceServer> create_resource_server(std::shared_ptr<ResourceManager> manager,
+                                                           Server& server) override;
+    std::shared_ptr<Resource> create_rpc_client(std::string name,
+                                                std::shared_ptr<grpc::Channel> chan) override;
+};
+
+/// @class GenericService generic.hpp "services/generic/generic.hpp"
+/// @brief A `GenericService` represents any service that can execute arbitrary commands.
+/// @ingroup GenericService
+///
+/// This acts as an abstract base class to be inherited from by any drivers representing
+/// specific generic service implementations. This class cannot be used on its own.
+class GenericService : public Service {
+   public:
+    /// @brief Creates a `ResourceRegistration` for the `GenericService`.
+    static std::shared_ptr<ResourceRegistration> resource_registration();
+
+    /// @brief Send/receive arbitrary commands to the resource.
+    /// @param command the command to execute.
+    /// @return The result of the executed command.
+    virtual AttributeMap do_command(AttributeMap command) = 0;
+
+    /// @brief Creates a `GenericService` `API`.
+    API api() const override;
+
+   protected:
+    explicit GenericService(std::string name);
+};
+
+template <>
+struct API::traits<GenericService> {
+    static API api();
+};
+
+}  // namespace sdk
+}  // namespace viam
diff --git a/src/viam/sdk/services/generic/server.cpp b/src/viam/sdk/services/generic/server.cpp
new file mode 100644
index 000000000..5403d41b3
--- /dev/null
+++ b/src/viam/sdk/services/generic/server.cpp
@@ -0,0 +1,25 @@
+#include <viam/sdk/services/generic/server.hpp>
+
+#include <viam/sdk/common/service_helper.hpp>
+#include <viam/sdk/rpc/server.hpp>
+#include <viam/sdk/services/generic/generic.hpp>
+
+namespace viam {
+namespace sdk {
+
+GenericServiceServer::GenericServiceServer(std::shared_ptr<ResourceManager> manager)
+    : ResourceServer(std::move(manager)){};
+
+::grpc::Status GenericServiceServer::DoCommand(
+    ::grpc::ServerContext* context,
+    const ::viam::common::v1::DoCommandRequest* request,
+    ::viam::common::v1::DoCommandResponse* response) noexcept {
+    return make_service_helper<GenericService>(
+        "GenericServiceServer::DoCommand", this, request)([&](auto& helper, auto& generic) {
+        const AttributeMap result = generic->do_command(struct_to_map(request->command()));
+        *response->mutable_result() = map_to_struct(result);
+    });
+}
+
+}  // namespace sdk
+}  // namespace viam
diff --git a/src/viam/sdk/services/generic/server.hpp b/src/viam/sdk/services/generic/server.hpp
new file mode 100644
index 000000000..f72ab2b94
--- /dev/null
+++ b/src/viam/sdk/services/generic/server.hpp
@@ -0,0 +1,29 @@
+/// @file services/generic/server.hpp
+///
+/// @brief Implements a gRPC server for the `GenericService`.
+#pragma once
+
+#include <viam/api/common/v1/common.grpc.pb.h>
+#include <viam/api/service/generic/v1/generic.grpc.pb.h>
+
+#include <viam/sdk/resource/resource_manager.hpp>
+#include <viam/sdk/resource/resource_server_base.hpp>
+
+namespace viam {
+namespace sdk {
+
+/// @class GenericServiceServer
+/// @brief gRPC server implementation of a `GenericService`.
+/// @ingroup GenericService
+class GenericServiceServer : public ResourceServer,
+                             public viam::service::generic::v1::GenericService::Service {
+   public:
+    explicit GenericServiceServer(std::shared_ptr<ResourceManager> manager);
+
+    ::grpc::Status DoCommand(::grpc::ServerContext* context,
+                             const ::viam::common::v1::DoCommandRequest* request,
+                             ::viam::common::v1::DoCommandResponse* response) noexcept override;
+};
+
+}  // namespace sdk
+}  // namespace viam
diff --git a/src/viam/sdk/tests/CMakeLists.txt b/src/viam/sdk/tests/CMakeLists.txt
index 9f1396e8a..b2d582942 100644
--- a/src/viam/sdk/tests/CMakeLists.txt
+++ b/src/viam/sdk/tests/CMakeLists.txt
@@ -44,7 +44,7 @@ viamcppsdk_add_boost_test(test_board.cpp)
 viamcppsdk_add_boost_test(test_camera.cpp)
 viamcppsdk_add_boost_test(test_common.cpp)
 viamcppsdk_add_boost_test(test_encoder.cpp)
-viamcppsdk_add_boost_test(test_generic_component.cpp)
+viamcppsdk_add_boost_test(test_generics.cpp)
 viamcppsdk_add_boost_test(test_mlmodel.cpp)
 viamcppsdk_add_boost_test(test_motor.cpp)
 viamcppsdk_add_boost_test(test_motion.cpp)
diff --git a/src/viam/sdk/tests/mocks/generic_mocks.cpp b/src/viam/sdk/tests/mocks/generic_mocks.cpp
index 4afd9306f..dac7cfa9b 100644
--- a/src/viam/sdk/tests/mocks/generic_mocks.cpp
+++ b/src/viam/sdk/tests/mocks/generic_mocks.cpp
@@ -16,21 +16,33 @@ namespace generic {
 using namespace viam::sdk;
 
 std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>>
-MockGeneric::do_command(
+MockGenericComponent::do_command(
     std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> command) {
     return map_;
 }
-std::vector<GeometryConfig> MockGeneric::get_geometries(const AttributeMap& extra) {
+std::vector<GeometryConfig> MockGenericComponent::get_geometries(const AttributeMap& extra) {
     return geometries_;
 }
-std::shared_ptr<MockGeneric> MockGeneric::get_mock_generic() {
-    auto generic = std::make_shared<MockGeneric>("mock_generic");
+std::shared_ptr<MockGenericComponent> MockGenericComponent::get_mock_generic() {
+    auto generic = std::make_shared<MockGenericComponent>("mock_generic");
     generic->map_ = fake_map();
     generic->geometries_ = fake_geometries();
 
     return generic;
 }
 
+std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>>
+MockGenericService::do_command(
+    std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> command) {
+    return map_;
+}
+std::shared_ptr<MockGenericService> MockGenericService::get_mock_generic() {
+    auto generic = std::make_shared<MockGenericService>("mock_generic");
+    generic->map_ = fake_map();
+
+    return generic;
+}
+
 }  // namespace generic
 }  // namespace sdktests
 }  // namespace viam
diff --git a/src/viam/sdk/tests/mocks/generic_mocks.hpp b/src/viam/sdk/tests/mocks/generic_mocks.hpp
index c4b501e82..7ac5a24b2 100644
--- a/src/viam/sdk/tests/mocks/generic_mocks.hpp
+++ b/src/viam/sdk/tests/mocks/generic_mocks.hpp
@@ -1,12 +1,13 @@
 #pragma once
 
 #include <viam/api/common/v1/common.pb.h>
-#include <viam/api/component/camera/v1/camera.grpc.pb.h>
-#include <viam/api/component/camera/v1/camera.pb.h>
 
 #include <viam/sdk/components/generic/client.hpp>
 #include <viam/sdk/components/generic/generic.hpp>
 #include <viam/sdk/components/generic/server.hpp>
+#include <viam/sdk/services/generic/client.hpp>
+#include <viam/sdk/services/generic/generic.hpp>
+#include <viam/sdk/services/generic/server.hpp>
 
 namespace viam {
 namespace sdktests {
@@ -14,14 +15,14 @@ namespace generic {
 
 using namespace viam::sdk;
 
-class MockGeneric : public Generic {
+class MockGenericComponent : public GenericComponent {
    public:
-    MockGeneric(std::string name) : Generic(std::move(name)){};
+    MockGenericComponent(std::string name) : GenericComponent(std::move(name)){};
     std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> do_command(
         std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> command)
         override;
 
-    static std::shared_ptr<MockGeneric> get_mock_generic();
+    static std::shared_ptr<MockGenericComponent> get_mock_generic();
     std::vector<GeometryConfig> get_geometries(const AttributeMap& extra) override;
 
    private:
@@ -29,6 +30,19 @@ class MockGeneric : public Generic {
     std::vector<GeometryConfig> geometries_;
 };
 
+class MockGenericService : public GenericService {
+   public:
+    MockGenericService(std::string name) : GenericService(std::move(name)){};
+    std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> do_command(
+        std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> command)
+        override;
+
+    static std::shared_ptr<MockGenericService> get_mock_generic();
+
+   private:
+    std::shared_ptr<std::unordered_map<std::string, std::shared_ptr<ProtoType>>> map_;
+};
+
 }  // namespace generic
 }  // namespace sdktests
 }  // namespace viam
diff --git a/src/viam/sdk/tests/test_generic_component.cpp b/src/viam/sdk/tests/test_generic_component.cpp
deleted file mode 100644
index 94a409e58..000000000
--- a/src/viam/sdk/tests/test_generic_component.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#define BOOST_TEST_MODULE test module test_generic_component
-
-#include <typeinfo>
-#include <unordered_map>
-#include <utility>
-
-#include <boost/test/included/unit_test.hpp>
-
-#include <viam/api/common/v1/common.pb.h>
-
-#include <viam/sdk/components/generic/client.hpp>
-#include <viam/sdk/components/generic/generic.hpp>
-#include <viam/sdk/components/generic/server.hpp>
-#include <viam/sdk/config/resource.hpp>
-#include <viam/sdk/spatialmath/geometry.hpp>
-#include <viam/sdk/tests/mocks/generic_mocks.hpp>
-#include <viam/sdk/tests/test_utils.hpp>
-
-namespace viam {
-namespace sdktests {
-
-using namespace generic;
-
-using namespace viam::sdk;
-
-BOOST_AUTO_TEST_SUITE(generic_suite)
-
-BOOST_AUTO_TEST_CASE(mock_get_api) {
-    const auto generic = MockGeneric::get_mock_generic();
-    auto api = generic->api();
-    auto static_api = API::get<Generic>();
-
-    BOOST_CHECK_EQUAL(api, static_api);
-    BOOST_CHECK_EQUAL(static_api.resource_subtype(), "generic");
-}
-
-BOOST_AUTO_TEST_CASE(test_do_command) {
-    std::shared_ptr<MockGeneric> mock = MockGeneric::get_mock_generic();
-    client_to_mock_pipeline<GenericClient>(mock, [](Generic& client) {
-        AttributeMap expected = fake_map();
-        AttributeMap command;
-        AttributeMap result_map = client.do_command(command);
-
-        std::shared_ptr<ProtoType> expected_pt = expected->at(std::string("test"));
-        std::shared_ptr<ProtoType> result_pt = result_map->at(std::string("test"));
-
-        BOOST_CHECK(*expected_pt == *result_pt);
-    });
-}
-
-BOOST_AUTO_TEST_CASE(test_get_geometries) {
-    std::shared_ptr<MockGeneric> mock = MockGeneric::get_mock_generic();
-    client_to_mock_pipeline<GenericClient>(mock, [](Generic& client) {
-        std::vector<GeometryConfig> expected_geometries = fake_geometries();
-        std::vector<GeometryConfig> result_geometries = client.get_geometries(fake_map());
-
-        BOOST_CHECK(expected_geometries == result_geometries);
-    });
-}
-
-BOOST_AUTO_TEST_SUITE_END()
-
-}  // namespace sdktests
-}  // namespace viam
diff --git a/src/viam/sdk/tests/test_generics.cpp b/src/viam/sdk/tests/test_generics.cpp
new file mode 100644
index 000000000..4ac4fd243
--- /dev/null
+++ b/src/viam/sdk/tests/test_generics.cpp
@@ -0,0 +1,87 @@
+#define BOOST_TEST_MODULE test module test_generic_component
+
+#include <typeinfo>
+#include <unordered_map>
+#include <utility>
+
+#include <boost/test/included/unit_test.hpp>
+
+#include <viam/api/common/v1/common.pb.h>
+
+#include <viam/sdk/components/generic/client.hpp>
+#include <viam/sdk/components/generic/generic.hpp>
+#include <viam/sdk/components/generic/server.hpp>
+#include <viam/sdk/config/resource.hpp>
+#include <viam/sdk/spatialmath/geometry.hpp>
+#include <viam/sdk/tests/mocks/generic_mocks.hpp>
+#include <viam/sdk/tests/test_utils.hpp>
+
+namespace viam {
+namespace sdktests {
+
+using namespace generic;
+
+using namespace viam::sdk;
+
+BOOST_AUTO_TEST_SUITE(generic_suite)
+
+BOOST_AUTO_TEST_CASE(mock_get_component_api) {
+    const auto generic = MockGenericComponent::get_mock_generic();
+    auto api = generic->api();
+    auto static_api = API::get<GenericComponent>();
+
+    BOOST_CHECK_EQUAL(api, static_api);
+    BOOST_CHECK_EQUAL(static_api.resource_subtype(), "generic");
+}
+
+BOOST_AUTO_TEST_CASE(test_component_do_command) {
+    std::shared_ptr<MockGenericComponent> mock = MockGenericComponent::get_mock_generic();
+    client_to_mock_pipeline<GenericComponentClient>(mock, [](GenericComponent& client) {
+        AttributeMap expected = fake_map();
+        AttributeMap command;
+        AttributeMap result_map = client.do_command(command);
+
+        std::shared_ptr<ProtoType> expected_pt = expected->at(std::string("test"));
+        std::shared_ptr<ProtoType> result_pt = result_map->at(std::string("test"));
+
+        BOOST_CHECK(*expected_pt == *result_pt);
+    });
+}
+
+BOOST_AUTO_TEST_CASE(test_component_get_geometries) {
+    std::shared_ptr<MockGenericComponent> mock = MockGenericComponent::get_mock_generic();
+    client_to_mock_pipeline<GenericComponentClient>(mock, [](GenericComponent& client) {
+        std::vector<GeometryConfig> expected_geometries = fake_geometries();
+        std::vector<GeometryConfig> result_geometries = client.get_geometries(fake_map());
+
+        BOOST_CHECK(expected_geometries == result_geometries);
+    });
+}
+
+BOOST_AUTO_TEST_CASE(mock_get_service_api) {
+    const auto generic = MockGenericService::get_mock_generic();
+    auto api = generic->api();
+    auto static_api = API::get<GenericService>();
+
+    BOOST_CHECK_EQUAL(api, static_api);
+    BOOST_CHECK_EQUAL(static_api.resource_subtype(), "generic");
+}
+
+BOOST_AUTO_TEST_CASE(test_service_do_command) {
+    std::shared_ptr<MockGenericService> mock = MockGenericService::get_mock_generic();
+    client_to_mock_pipeline<GenericServiceClient>(mock, [](GenericService& client) {
+        AttributeMap expected = fake_map();
+        AttributeMap command;
+        AttributeMap result_map = client.do_command(command);
+
+        std::shared_ptr<ProtoType> expected_pt = expected->at(std::string("test"));
+        std::shared_ptr<ProtoType> result_pt = result_map->at(std::string("test"));
+
+        BOOST_CHECK(*expected_pt == *result_pt);
+    });
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+}  // namespace sdktests
+}  // namespace viam
diff --git a/src/viam/sdk/tests/test_robot.cpp b/src/viam/sdk/tests/test_robot.cpp
index 5f171503b..836a91cbc 100644
--- a/src/viam/sdk/tests/test_robot.cpp
+++ b/src/viam/sdk/tests/test_robot.cpp
@@ -41,7 +41,7 @@ void robot_client_to_mocks_pipeline(F&& test_case) {
     // ResourceManager. Create a Server. Create a MockRobotService from the
     // ResourceManager and Server. Start the Server.
     auto rm = std::make_shared<ResourceManager>();
-    rm->add(std::string("mock_generic"), generic::MockGeneric::get_mock_generic());
+    rm->add(std::string("mock_generic"), generic::MockGenericComponent::get_mock_generic());
     rm->add(std::string("mock_motor"), motor::MockMotor::get_mock_motor());
     rm->add(std::string("mock_camera"), camera::MockCamera::get_mock_camera());
     auto server = std::make_shared<sdk::Server>();
@@ -77,9 +77,11 @@ BOOST_AUTO_TEST_CASE(test_registering_resources) {
 
     Model generic_model("fake", "fake", "mock_generic");
     std::shared_ptr<ModelRegistration> gr = std::make_shared<ModelRegistration>(
-        API::get<Generic>(),
+        API::get<GenericComponent>(),
         generic_model,
-        [](Dependencies, ResourceConfig cfg) { return generic::MockGeneric::get_mock_generic(); },
+        [](Dependencies, ResourceConfig cfg) {
+            return generic::MockGenericComponent::get_mock_generic();
+        },
         [](ResourceConfig cfg) -> std::vector<std::string> { return {}; });
     Registry::register_model(gr);
 
@@ -92,7 +94,7 @@ BOOST_AUTO_TEST_CASE(test_registering_resources) {
     Registry::register_model(mr);
 
     BOOST_CHECK(Registry::lookup_model(API::get<Camera>(), camera_model));
-    BOOST_CHECK(Registry::lookup_model(API::get<Generic>(), generic_model));
+    BOOST_CHECK(Registry::lookup_model(API::get<GenericComponent>(), generic_model));
     BOOST_CHECK(Registry::lookup_model(API::get<Motor>(), motor_model));
 }