diff --git a/giterated-stack/src/handler.rs b/giterated-stack/src/handler.rs
index 9e56b23..df1fa11 100644
--- a/giterated-stack/src/handler.rs
+++ b/giterated-stack/src/handler.rs
@@ -14,8 +14,8 @@ use giterated_models::{
     settings::{GetSetting, GetSettingError, SetSetting, Setting},
     value::{AnyValue, GetValue, GetValueTyped, GiteratedObjectValue},
 };
-use serde_json::Value;
-use tracing::{info, trace};
+
+use tracing::trace;
 
 use crate::{
     GiteratedOperationHandler, ObjectMeta, ObjectOperationPair, ObjectValuePair, OperationMeta,
@@ -315,11 +315,7 @@ impl RuntimeMetadata {
     fn register_object<O: GiteratedObject + 'static>(&mut self) {
         let object_name = O::object_name().to_string();
 
-        let object_meta = ObjectMeta {
-            name: object_name.clone(),
-            from_str: Box::new(|str| Ok(Box::new(O::from_str(&str).map_err(|_| ())?))),
-            any_is_same: Box::new(|any| any.is::<O>()),
-        };
+        let object_meta = ObjectMeta::new::<O>();
 
         if self.objects.insert(object_name, object_meta).is_some() {
             trace!(
@@ -344,23 +340,7 @@ impl RuntimeMetadata {
                     object_name: object_name.clone(),
                     operation_name: operation_name.clone(),
                 },
-                OperationMeta {
-                    name: operation_name,
-                    object_kind: object_name,
-                    deserialize: Box::new(|bytes| {
-                        Ok(Box::new(serde_json::from_slice::<D>(bytes)?)
-                            as Box<dyn Any + Send + Sync>)
-                    }),
-                    any_is_same: Box::new(|any_box| any_box.is::<D>()),
-                    serialize_success: Box::new(|any| {
-                        let to_serialize = any.downcast::<D::Success>().unwrap();
-                        serde_json::to_vec(&to_serialize)
-                    }),
-                    serialize_error: Box::new(|any| {
-                        let to_serialize = any.downcast::<D::Failure>().unwrap();
-                        serde_json::to_vec(&to_serialize)
-                    }),
-                },
+                OperationMeta::new::<O, D>(),
             )
             .is_some()
         {
@@ -386,7 +366,6 @@ impl RuntimeMetadata {
     ) {
         let object_name = O::object_name().to_string();
         let value_name = V::value_name().to_string();
-        let value_name_for_get = V::value_name().to_string();
 
         if self
             .values
@@ -395,22 +374,7 @@ impl RuntimeMetadata {
                     object_kind: object_name.clone(),
                     value_kind: value_name.clone(),
                 },
-                ValueMeta {
-                    name: value_name.clone(),
-                    deserialize: Box::new(|bytes| Ok(Box::new(serde_json::from_slice(&bytes)?))),
-                    serialize: Box::new(|value| {
-                        let value = value.downcast::<V>().unwrap();
-
-                        Ok(serde_json::to_vec(&*value)?)
-                    }),
-                    typed_get: Box::new(move || {
-                        Box::new(GetValueTyped::<V> {
-                            value_name: value_name_for_get.clone(),
-                            ty: Default::default(),
-                        })
-                    }),
-                    is_get_value_typed: Box::new(move |typed| typed.is::<GetValueTyped<V>>()),
-                },
+                ValueMeta::new::<V>(),
             )
             .is_some()
         {
@@ -433,14 +397,7 @@ impl RuntimeMetadata {
 
         if self
             .settings
-            .insert(
-                setting_name.clone(),
-                SettingMeta {
-                    name: setting_name,
-                    deserialize: Box::new(|bytes| Ok(Box::new(serde_json::from_slice(bytes)?))),
-                    serialize: Box::new(|source| Ok(*source.downcast::<Value>().unwrap())),
-                },
-            )
+            .insert(setting_name.clone(), SettingMeta::new::<S>())
             .is_some()
         {
             trace!(
@@ -499,20 +456,16 @@ impl GiteratedStack {
                 .await;
         } else if message.operation == "get_setting" {
             let operation: GetSetting = serde_json::from_slice(&message.payload.0).unwrap();
-            info!("1");
             let setting_meta = self
                 .metadata
                 .settings
                 .get(&operation.setting_name)
                 .ok_or_else(|| OperationError::Unhandled)?;
-            info!("2");
             let raw_result = self
                 .get_setting(object, object_type.clone(), operation, operation_state)
                 .await;
-            info!("3");
             return match raw_result {
                 Ok(success) => {
-                    info!("3a");
                     // Success is the setting type, serialize it
                     let serialized = (setting_meta.serialize)(success).unwrap();
 
@@ -520,7 +473,6 @@ impl GiteratedStack {
                 }
                 Err(err) => Err(match err {
                     OperationError::Operation(failure) => {
-                        info!("3b");
                         // We know how to resolve this type
                         let failure: GetSettingError = *failure.downcast().unwrap();
 
@@ -703,23 +655,6 @@ impl ObjectBackend<StackOperationState> for Arc<GiteratedStack> {
         let object = Box::new(in_object.clone()) as Box<dyn Any + Send + Sync>;
         let operation = Box::new(payload) as Box<dyn Any + Send + Sync>;
 
-        // We need to determine the type of the object, iterate through all known
-        // object types and check if the &dyn Any we have is the same type as the
-        // object type.
-        let object_type = {
-            let mut object_type = None;
-
-            for (object_name, object_meta) in self.metadata.objects.iter() {
-                if (object_meta.any_is_same)(&in_object) {
-                    object_type = Some(object_name.clone());
-                    break;
-                }
-            }
-
-            object_type
-        }
-        .ok_or_else(|| OperationError::Unhandled)?;
-
         // We need to hijack get_value, set_setting, and get_setting.
         if operation_name == "get_value" {
             let mut value_meta = None;
@@ -734,10 +669,14 @@ impl ObjectBackend<StackOperationState> for Arc<GiteratedStack> {
 
             let value_name = value_meta.name.clone();
 
-            trace!("Handling get_value for {}::{}", object_type, value_name);
+            trace!(
+                "Handling get_value for {}::{}",
+                O::object_name(),
+                value_name
+            );
 
             for (target, getter) in self.value_getters.iter() {
-                if target.object_kind != object_type {
+                if target.object_kind != O::object_name() {
                     continue;
                 }
 
@@ -763,16 +702,14 @@ impl ObjectBackend<StackOperationState> for Arc<GiteratedStack> {
             return Err(OperationError::Unhandled);
         } else if operation.is::<GetSetting>() {
             let get_setting: Box<GetSetting> = operation.downcast().unwrap();
-            let _setting_name = get_setting.setting_name.clone();
-
-            let _setting_meta = self
-                .metadata
-                .settings
-                .get(&object_type)
-                .ok_or_else(|| OperationError::Unhandled)?;
 
             let raw_result = self
-                .get_setting(object, object_type.clone(), *get_setting, operation_state)
+                .get_setting(
+                    object,
+                    O::object_name().to_string(),
+                    *get_setting,
+                    operation_state,
+                )
                 .await;
 
             return match raw_result {
@@ -804,7 +741,7 @@ impl ObjectBackend<StackOperationState> for Arc<GiteratedStack> {
 
             for (target, operation_meta) in self.metadata.operations.iter() {
                 // Skip elements that we know will not match
-                if target.object_name != object_type {
+                if target.object_name != O::object_name() {
                     continue;
                 }
 
diff --git a/giterated-stack/src/lib.rs b/giterated-stack/src/lib.rs
index 9240e93..2ba5444 100644
--- a/giterated-stack/src/lib.rs
+++ b/giterated-stack/src/lib.rs
@@ -1,7 +1,7 @@
 mod handler;
+mod meta;
 pub use handler::{GiteratedStack, GiteratedStackState, *};
-use serde_json::Value;
-
+pub use meta::*;
 pub mod state;
 pub mod update;
 
@@ -30,40 +30,6 @@ struct ObjectOperationPair {
     pub operation_name: String,
 }
 
-pub struct SettingMeta {
-    pub name: String,
-    pub deserialize: Box<dyn Fn(&[u8]) -> Result<Box<dyn Any>, serde_json::Error> + Send + Sync>,
-    pub serialize:
-        Box<dyn Fn(Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error> + Send + Sync>,
-}
-
-pub struct ValueMeta {
-    pub name: String,
-    pub deserialize: Box<dyn Fn(&[u8]) -> Result<Box<dyn Any>, serde_json::Error> + Send + Sync>,
-    pub serialize:
-        Box<dyn Fn(Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error> + Send + Sync>,
-    pub typed_get: Box<dyn Fn() -> Box<dyn Any + Send + Sync> + Send + Sync>,
-    pub is_get_value_typed: Box<dyn Fn(&Box<dyn Any + Send + Sync>) -> bool + Send + Sync>,
-}
-
-pub struct ObjectMeta {
-    pub name: String,
-    pub from_str: Box<dyn Fn(&str) -> Result<Box<dyn Any + Send + Sync>, ()> + Send + Sync>,
-    pub any_is_same: Box<dyn Fn(&dyn Any) -> bool + Send + Sync>,
-}
-
-pub struct OperationMeta {
-    pub name: String,
-    pub object_kind: String,
-    pub deserialize:
-        Box<dyn Fn(&[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error> + Send + Sync>,
-    pub any_is_same: Box<dyn Fn(&dyn Any) -> bool + Send + Sync>,
-    pub serialize_success:
-        Box<dyn Fn(Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> + Send + Sync>,
-    pub serialize_error:
-        Box<dyn Fn(Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> + Send + Sync>,
-}
-
 #[derive(Clone, Debug, Hash, Eq, PartialEq)]
 pub struct ObjectValuePair {
     pub object_kind: String,
diff --git a/giterated-stack/src/meta/mod.rs b/giterated-stack/src/meta/mod.rs
new file mode 100644
index 0000000..562e0ab
--- /dev/null
+++ b/giterated-stack/src/meta/mod.rs
@@ -0,0 +1,200 @@
+use std::{any::Any, str::FromStr};
+
+use giterated_models::{
+    object::GiteratedObject,
+    operation::GiteratedOperation,
+    settings::Setting,
+    value::{GetValueTyped, GiteratedObjectValue},
+};
+use serde_json::Value;
+
+pub struct ValueMeta {
+    pub name: String,
+    pub deserialize: Box<dyn Fn(&[u8]) -> Result<Box<dyn Any>, serde_json::Error> + Send + Sync>,
+    pub serialize:
+        Box<dyn Fn(Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error> + Send + Sync>,
+    pub typed_get: Box<dyn Fn() -> Box<dyn Any + Send + Sync> + Send + Sync>,
+    pub is_get_value_typed: Box<dyn Fn(&Box<dyn Any + Send + Sync>) -> bool + Send + Sync>,
+}
+
+pub trait IntoValueMeta {
+    fn name() -> String;
+    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error>;
+    fn serialize(value: Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error>;
+    fn typed_get() -> Box<dyn Any + Send + Sync>;
+    fn is_get_value_typed(typed_get_value: &Box<dyn Any + Send + Sync>) -> bool;
+}
+
+impl<O: GiteratedObject, V: GiteratedObjectValue<Object = O> + 'static> IntoValueMeta for V {
+    fn name() -> String {
+        V::value_name().to_string()
+    }
+
+    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error> {
+        Ok(Box::new(serde_json::from_slice(&buffer)?))
+    }
+
+    fn serialize(value: Box<dyn Any + Send + Sync>) -> Result<Vec<u8>, serde_json::Error> {
+        let value = value.downcast::<V>().unwrap();
+
+        Ok(serde_json::to_vec(&*value)?)
+    }
+
+    fn typed_get() -> Box<dyn Any + Send + Sync> {
+        Box::new(GetValueTyped::<V> {
+            value_name: V::value_name().to_string(),
+            ty: Default::default(),
+        })
+    }
+
+    fn is_get_value_typed(typed_get_value: &Box<dyn Any + Send + Sync>) -> bool {
+        typed_get_value.is::<GetValueTyped<V>>()
+    }
+}
+
+impl ValueMeta {
+    pub fn new<I: IntoValueMeta + 'static>() -> Self {
+        Self {
+            name: I::name(),
+            deserialize: Box::new(I::deserialize) as _,
+            serialize: Box::new(I::serialize) as _,
+            typed_get: Box::new(I::typed_get) as _,
+            is_get_value_typed: Box::new(I::is_get_value_typed) as _,
+        }
+    }
+}
+
+pub struct OperationMeta {
+    pub name: String,
+    pub object_kind: String,
+    pub deserialize:
+        Box<dyn Fn(&[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error> + Send + Sync>,
+    pub any_is_same: Box<dyn Fn(&dyn Any) -> bool + Send + Sync>,
+    pub serialize_success:
+        Box<dyn Fn(Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> + Send + Sync>,
+    pub serialize_error:
+        Box<dyn Fn(Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> + Send + Sync>,
+}
+
+pub trait IntoOperationMeta<O> {
+    fn name() -> String;
+    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error>;
+    fn serialize_success(success: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error>;
+    fn serialize_failure(failure: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error>;
+    fn any_is_same(other: &dyn Any) -> bool;
+}
+
+impl<O, D> IntoOperationMeta<O> for D
+where
+    D::Failure: 'static,
+    D::Success: 'static,
+    O: GiteratedObject,
+    D: GiteratedOperation<O> + 'static,
+{
+    fn name() -> String {
+        D::operation_name().to_string()
+    }
+
+    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any + Send + Sync>, serde_json::Error> {
+        Ok(Box::new(serde_json::from_slice::<D>(buffer)?) as Box<dyn Any + Send + Sync>)
+    }
+
+    fn serialize_success(success: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> {
+        let to_serialize = success.downcast::<D::Success>().unwrap();
+        serde_json::to_vec(&to_serialize)
+    }
+
+    fn serialize_failure(failure: Box<dyn Any>) -> Result<Vec<u8>, serde_json::Error> {
+        let to_serialize = failure.downcast::<D::Failure>().unwrap();
+        serde_json::to_vec(&to_serialize)
+    }
+
+    fn any_is_same(other: &dyn Any) -> bool {
+        other.is::<D>()
+    }
+}
+
+impl OperationMeta {
+    pub fn new<O: GiteratedObject + 'static, I: IntoOperationMeta<O> + 'static>() -> Self {
+        Self {
+            name: I::name(),
+            deserialize: Box::new(I::deserialize) as _,
+            serialize_success: Box::new(I::serialize_success) as _,
+            serialize_error: Box::new(I::serialize_failure) as _,
+            object_kind: O::object_name().to_string(),
+            any_is_same: Box::new(I::any_is_same) as _,
+        }
+    }
+}
+
+pub struct ObjectMeta {
+    pub name: String,
+    pub from_str: Box<dyn Fn(&str) -> Result<Box<dyn Any + Send + Sync>, ()> + Send + Sync>,
+    pub any_is_same: Box<dyn Fn(&dyn Any) -> bool + Send + Sync>,
+}
+
+pub trait IntoObjectMeta: FromStr {
+    fn name() -> String;
+    fn any_is_same(other: &dyn Any) -> bool;
+}
+
+impl<O: GiteratedObject + 'static> IntoObjectMeta for O {
+    fn name() -> String {
+        O::object_name().to_string()
+    }
+
+    fn any_is_same(other: &dyn Any) -> bool {
+        other.is::<O>()
+    }
+}
+
+impl ObjectMeta {
+    pub fn new<I: IntoObjectMeta + Send + Sync + 'static>() -> Self {
+        Self {
+            name: I::name(),
+            from_str: Box::new(|source| {
+                let object = I::from_str(source).map_err(|_| ())?;
+
+                Ok(Box::new(object) as Box<dyn Any + Send + Sync>)
+            }),
+            any_is_same: Box::new(I::any_is_same) as _,
+        }
+    }
+}
+
+pub struct SettingMeta {
+    pub name: String,
+    pub deserialize: Box<dyn Fn(&[u8]) -> Result<Box<dyn Any>, serde_json::Error> + Send + Sync>,
+    pub serialize:
+        Box<dyn Fn(Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error> + Send + Sync>,
+}
+
+pub trait IntoSettingMeta {
+    fn name() -> String;
+    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error>;
+    fn serialize(setting: Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error>;
+}
+
+impl<S: Setting> IntoSettingMeta for S {
+    fn name() -> String {
+        S::name().to_string()
+    }
+
+    fn deserialize(buffer: &[u8]) -> Result<Box<dyn Any>, serde_json::Error> {
+        Ok(Box::new(serde_json::from_slice(buffer)?))
+    }
+
+    fn serialize(setting: Box<dyn Any + Send + Sync>) -> Result<Value, serde_json::Error> {
+        Ok(*setting.downcast::<Value>().unwrap())
+    }
+}
+
+impl SettingMeta {
+    pub fn new<I: IntoSettingMeta + 'static>() -> Self {
+        Self {
+            name: I::name(),
+            deserialize: Box::new(I::deserialize) as _,
+            serialize: Box::new(I::serialize) as _,
+        }
+    }
+}