diff --git a/giterated-daemon/src/database_backend/handler.rs b/giterated-daemon/src/database_backend/handler.rs
index 799341f..f270a6f 100644
--- a/giterated-daemon/src/database_backend/handler.rs
+++ b/giterated-daemon/src/database_backend/handler.rs
@@ -19,7 +19,7 @@ use giterated_models::{
     user::{User, UserRepositoriesRequest},
     value::{AnyValue, GetValue},
 };
-use giterated_stack::{AuthenticatedUser, BackendWrapper, StackOperationState};
+use giterated_stack::{AuthenticatedUser, AuthorizedInstance, BackendWrapper, StackOperationState};
 
 use super::DatabaseBackend;
 
@@ -382,6 +382,8 @@ pub fn instance_authentication_request(
     object: &Instance,
     operation: AuthenticationTokenRequest,
     state: DatabaseBackend,
+    // Authorizes the request for SAME-INSTANCE
+    _authorized_instance: AuthorizedInstance,
 ) -> BoxFuture<'static, Result<UserAuthenticationToken, OperationError<InstanceError>>> {
     let object = object.clone();
     async move {
@@ -399,6 +401,8 @@ pub fn instance_registration_request(
     _object: &Instance,
     operation: RegisterAccountRequest,
     state: DatabaseBackend,
+    // Authorizes the request for SAME-INSTANCE
+    _authorized_instance: AuthorizedInstance,
 ) -> BoxFuture<'static, Result<UserAuthenticationToken, OperationError<InstanceError>>> {
     async move {
         let mut backend = state.user_backend.lock().await;
@@ -416,6 +420,8 @@ pub fn instance_create_repository_request(
     operation: RepositoryCreateRequest,
     state: DatabaseBackend,
     requester: AuthenticatedUser,
+    // Authorizes the request for SAME-INSTANCE
+    _authorized_instance: AuthorizedInstance,
 ) -> BoxFuture<'static, Result<Repository, OperationError<InstanceError>>> {
     async move {
         let mut backend = state.repository_backend.lock().await;
diff --git a/giterated-daemon/src/main.rs b/giterated-daemon/src/main.rs
index 98e705a..6da61dc 100644
--- a/giterated-daemon/src/main.rs
+++ b/giterated-daemon/src/main.rs
@@ -95,6 +95,8 @@ async fn main() -> Result<(), Error> {
 
     let operation_state = {
         StackOperationState {
+            our_instance: Instance::from_str(config["giterated"]["instance"].as_str().unwrap())
+                .unwrap(),
             giterated_backend: backend_wrapper,
             instance: None,
             user: None,
diff --git a/giterated-models/src/lib.rs b/giterated-models/src/lib.rs
index 57e5bc4..0c0c39d 100644
--- a/giterated-models/src/lib.rs
+++ b/giterated-models/src/lib.rs
@@ -1,3 +1,7 @@
+use error::OperationError;
+use object::GiteratedObject;
+use operation::GiteratedOperation;
+
 pub mod authenticated;
 pub mod discovery;
 pub mod error;
diff --git a/giterated-stack/src/lib.rs b/giterated-stack/src/lib.rs
index 03b61fa..686f411 100644
--- a/giterated-stack/src/lib.rs
+++ b/giterated-stack/src/lib.rs
@@ -6,7 +6,9 @@ use std::{collections::HashMap, future::Future, ops::Deref, pin::Pin, str::FromS
 use futures_util::FutureExt;
 use giterated_models::{
     error::OperationError,
-    instance::Instance,
+    instance::{
+        AuthenticationTokenRequest, Instance, RegisterAccountRequest, RepositoryCreateRequest,
+    },
     object::{
         AnyObject, GiteratedObject, Object, ObjectRequest, ObjectRequestError, ObjectResponse,
     },
@@ -224,10 +226,10 @@ where
         + Sync
         + Clone,
     O: GiteratedObject + Send + Sync,
-    D: GiteratedOperation<O> + 'static,
+    D: GiteratedOperation<O> + 'static + Send + Sync,
     <D as GiteratedOperation<O>>::Failure: Send,
     S: Send + Sync + Clone + 'static,
-    O1: FromOperationState,
+    O1: FromOperationState<O, D>,
 {
     fn operation_name(&self) -> &str {
         D::operation_name()
@@ -244,7 +246,7 @@ where
         state: S,
         operation_state: &StackOperationState,
     ) -> Result<D::Success, OperationError<D::Failure>> {
-        let o1 = O1::from_state(operation_state)
+        let o1 = O1::from_state(object, &operation, operation_state)
             .await
             .map_err(|e| OperationError::Internal(e.to_string()))?;
         self.clone()(object, operation, state, o1).await
@@ -266,11 +268,11 @@ where
         + Sync
         + Clone,
     O: GiteratedObject + Send + Sync,
-    D: GiteratedOperation<O> + 'static,
+    D: GiteratedOperation<O> + 'static + Send + Sync,
     <D as GiteratedOperation<O>>::Failure: Send,
     S: Send + Sync + Clone + 'static,
-    O1: FromOperationState,
-    O2: FromOperationState,
+    O1: FromOperationState<O, D>,
+    O2: FromOperationState<O, D>,
 {
     fn operation_name(&self) -> &str {
         D::operation_name()
@@ -287,10 +289,10 @@ where
         state: S,
         operation_state: &StackOperationState,
     ) -> Result<D::Success, OperationError<D::Failure>> {
-        let o1 = O1::from_state(operation_state)
+        let o1 = O1::from_state(object, &operation, operation_state)
             .await
             .map_err(|e| OperationError::Internal(e.to_string()))?;
-        let o2 = O2::from_state(operation_state)
+        let o2 = O2::from_state(object, &operation, operation_state)
             .await
             .map_err(|e| OperationError::Internal(e.to_string()))?;
         self.clone()(object, operation, state, o1, o2).await
@@ -313,12 +315,12 @@ where
         + Sync
         + Clone,
     O: GiteratedObject + Send + Sync,
-    D: GiteratedOperation<O> + 'static,
+    D: GiteratedOperation<O> + 'static + Send + Sync,
     <D as GiteratedOperation<O>>::Failure: Send,
     S: Send + Sync + Clone + 'static,
-    O1: FromOperationState,
-    O2: FromOperationState,
-    O3: FromOperationState,
+    O1: FromOperationState<O, D>,
+    O2: FromOperationState<O, D>,
+    O3: FromOperationState<O, D>,
 {
     fn operation_name(&self) -> &str {
         D::operation_name()
@@ -335,13 +337,13 @@ where
         state: S,
         operation_state: &StackOperationState,
     ) -> Result<D::Success, OperationError<D::Failure>> {
-        let o1 = O1::from_state(operation_state)
+        let o1 = O1::from_state(object, &operation, operation_state)
             .await
             .map_err(|e| OperationError::Internal(e.to_string()))?;
-        let o2 = O2::from_state(operation_state)
+        let o2 = O2::from_state(object, &operation, operation_state)
             .await
             .map_err(|e| OperationError::Internal(e.to_string()))?;
-        let o3 = O3::from_state(operation_state)
+        let o3 = O3::from_state(object, &operation, operation_state)
             .await
             .map_err(|e| OperationError::Internal(e.to_string()))?;
         self.clone()(object, operation, state, o1, o2, o3).await
@@ -416,26 +418,42 @@ impl<S: Send + Sync + Clone + 'static> OperationWrapper<S> {
 }
 
 #[async_trait::async_trait]
-pub trait FromOperationState: Sized + Clone + Send {
+pub trait FromOperationState<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync>:
+    Sized + Clone + Send
+{
     type Error: Serialize + DeserializeOwned;
 
-    async fn from_state(state: &StackOperationState) -> Result<Self, OperationError<Self::Error>>;
+    async fn from_state(
+        object: &O,
+        operation: &D,
+        state: &StackOperationState,
+    ) -> Result<Self, OperationError<Self::Error>>;
 }
 
 #[async_trait::async_trait]
-impl FromOperationState for BackendWrapper {
+impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
+    for BackendWrapper
+{
     type Error = ();
 
-    async fn from_state(state: &StackOperationState) -> Result<Self, OperationError<()>> {
+    async fn from_state(
+        _object: &O,
+        _operation: &D,
+        state: &StackOperationState,
+    ) -> Result<Self, OperationError<()>> {
         Ok(state.giterated_backend.clone())
     }
 }
 
 #[async_trait::async_trait]
-impl FromOperationState for StackOperationState {
+impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
+    for StackOperationState
+{
     type Error = ();
 
     async fn from_state(
+        _object: &O,
+        _operation: &D,
         state: &StackOperationState,
     ) -> Result<StackOperationState, OperationError<()>> {
         Ok(state.clone())
@@ -443,10 +461,14 @@ impl FromOperationState for StackOperationState {
 }
 
 #[async_trait::async_trait]
-impl FromOperationState for AuthenticatedUser {
+impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
+    for AuthenticatedUser
+{
     type Error = ();
 
     async fn from_state(
+        _object: &O,
+        _operation: &D,
         state: &StackOperationState,
     ) -> Result<AuthenticatedUser, OperationError<()>> {
         state
@@ -457,10 +479,14 @@ impl FromOperationState for AuthenticatedUser {
 }
 
 #[async_trait::async_trait]
-impl FromOperationState for AuthenticatedInstance {
+impl<O: GiteratedObject, D: GiteratedOperation<O> + Send + Sync> FromOperationState<O, D>
+    for AuthenticatedInstance
+{
     type Error = ();
 
     async fn from_state(
+        _object: &O,
+        _operation: &D,
         state: &StackOperationState,
     ) -> Result<AuthenticatedInstance, OperationError<()>> {
         state
@@ -471,16 +497,141 @@ impl FromOperationState for AuthenticatedInstance {
 }
 
 #[async_trait::async_trait]
-impl<T: FromOperationState> FromOperationState for Option<T> {
+impl<
+        T: FromOperationState<O, D> + Send + Sync,
+        O: GiteratedObject + Sync,
+        D: GiteratedOperation<O> + Send + Sync,
+    > FromOperationState<O, D> for Option<T>
+{
+    type Error = ();
+
+    async fn from_state(
+        object: &O,
+        operation: &D,
+        state: &StackOperationState,
+    ) -> Result<Option<T>, OperationError<()>> {
+        Ok(T::from_state(object, operation, state).await.ok())
+    }
+}
+
+#[derive(Clone)]
+pub struct AuthorizedUser(AuthenticatedUser);
+
+#[derive(Clone)]
+pub struct AuthorizedInstance(AuthenticatedInstance);
+
+#[async_trait::async_trait]
+pub trait AuthorizedOperation<O: GiteratedObject>: GiteratedOperation<O> {
+    async fn authorize(
+        &self,
+        authorize_for: &O,
+        state: &StackOperationState,
+    ) -> Result<bool, OperationError<()>>;
+}
+
+#[async_trait::async_trait]
+impl AuthorizedOperation<Instance> for RegisterAccountRequest {
+    async fn authorize(
+        &self,
+        authorize_for: &Instance,
+        state: &StackOperationState,
+    ) -> Result<bool, OperationError<()>> {
+        if state.our_instance == *authorize_for {
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl AuthorizedOperation<Instance> for AuthenticationTokenRequest {
+    async fn authorize(
+        &self,
+        authorize_for: &Instance,
+        state: &StackOperationState,
+    ) -> Result<bool, OperationError<()>> {
+        if state.our_instance == *authorize_for {
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl AuthorizedOperation<Instance> for RepositoryCreateRequest {
+    async fn authorize(
+        &self,
+        authorize_for: &Instance,
+        state: &StackOperationState,
+    ) -> Result<bool, OperationError<()>> {
+        if state.our_instance == *authorize_for {
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl<A: AuthorizedOperation<User> + Send + Sync> FromOperationState<User, A> for AuthorizedUser {
     type Error = ();
 
-    async fn from_state(state: &StackOperationState) -> Result<Option<T>, OperationError<()>> {
-        Ok(T::from_state(state).await.ok())
+    async fn from_state(
+        object: &User,
+        operation: &A,
+        state: &StackOperationState,
+    ) -> Result<AuthorizedUser, OperationError<()>> {
+        let authenticated = AuthenticatedUser::from_state(object, operation, state).await?;
+
+        match operation.authorize(object, state).await {
+            Ok(authorized) => {
+                assert!(authorized);
+            }
+            Err(err) => return Err(OperationError::Internal(err.to_string())),
+        };
+
+        Ok(AuthorizedUser(authenticated))
     }
 }
 
+#[async_trait::async_trait]
+impl<A: AuthorizedOperation<Instance> + Send + Sync> FromOperationState<Instance, A>
+    for AuthorizedInstance
+{
+    type Error = ();
+
+    async fn from_state(
+        object: &Instance,
+        operation: &A,
+        state: &StackOperationState,
+    ) -> Result<AuthorizedInstance, OperationError<()>> {
+        let authenticated = AuthenticatedInstance::from_state(object, operation, state).await?;
+
+        match operation.authorize(object, state).await {
+            Ok(authorized) => {
+                assert!(authorized);
+            }
+            Err(err) => return Err(OperationError::Internal(err.to_string())),
+        };
+
+        Ok(AuthorizedInstance(authenticated))
+    }
+}
+
+// #[async_trait::async_trait> FromOperationState for Option<T> {
+//     type Error = ();
+
+//     async fn from_state(state: &StackOperationState) -> Result<Option<T>, OperationError<()>> {
+//         Ok(T::from_state(]
+// impl<T: FromOperationStatestate).await.ok())
+//     }
+// }
+
 #[derive(Clone)]
 pub struct StackOperationState {
+    pub our_instance: Instance,
     pub giterated_backend: BackendWrapper,
     pub instance: Option<AuthenticatedInstance>,
     pub user: Option<AuthenticatedUser>,