diff --git a/apps/console/src/routes.tsx b/apps/console/src/routes.tsx
index 3fb931782..cfcbdea6b 100644
--- a/apps/console/src/routes.tsx
+++ b/apps/console/src/routes.tsx
@@ -1,7 +1,7 @@
 import { Role } from "@probo/helpers";
 import { lazy } from "@probo/react-lazy";
 import {
-  NotAssumingError,
+  AssumptionRequiredError,
   UnAuthenticatedError,
 } from "@probo/relay";
 import { type AppRoute, routeFromAppRoute } from "@probo/routes";
@@ -48,7 +48,7 @@ function ErrorBoundary() {
     return <Navigate to="/auth/login" />;
   }
 
-  if (error instanceof NotAssumingError) {
+  if (error instanceof AssumptionRequiredError) {
     // TODO redirect to right URL
     return <Navigate to="/" />;
   }
diff --git a/packages/relay/src/errors.ts b/packages/relay/src/errors.ts
index 84dcb9630..dadf7b36a 100644
--- a/packages/relay/src/errors.ts
+++ b/packages/relay/src/errors.ts
@@ -14,11 +14,11 @@ export class InternalServerError extends Error {
   }
 }
 
-export class NotAssumingError extends Error {
+export class AssumptionRequiredError extends Error {
   constructor(message?: string) {
-    super(message ?? "NOT_ASSUMING");
-    this.name = "NotAssumingError";
-    Object.setPrototypeOf(this, NotAssumingError.prototype)
+    super(message ?? "ASSUMPTION_REQUIRED");
+    this.name = "AssumptionRequiredError";
+    Object.setPrototypeOf(this, AssumptionRequiredError.prototype)
   }
 }
 
diff --git a/packages/relay/src/fetch.ts b/packages/relay/src/fetch.ts
index e5f31dd58..1b1d9a4b5 100644
--- a/packages/relay/src/fetch.ts
+++ b/packages/relay/src/fetch.ts
@@ -4,15 +4,15 @@ import {
     UnAuthenticatedError,
     UnauthorizedError,
     ForbiddenError,
-    NotAssumingError,
+    AssumptionRequiredError,
 } from "./errors";
 import { GraphQLError } from "graphql";
 
 const hasUnauthenticatedError = (error: GraphQLError) =>
     error.extensions?.code == "UNAUTHENTICATED";
 
-const hasNotAssumingError = (error: GraphQLError) =>
-    error.extensions?.code == "NOT_ASSUMING";
+const hasAssumptionRequiredError = (error: GraphQLError) =>
+    error.extensions?.code == "ASSUMPTION_REQUIRED";
 
 const hasUnauthorizedError = (error: GraphQLError) =>
     error.extensions?.code == "UNAUTHORIZED";
@@ -83,9 +83,9 @@ export const makeFetchQuery = (endpoint: string): FetchFunction => {
                 throw new UnAuthenticatedError(unauthenticatedError.message);
             }
 
-            const notAssumingError = errors.find(hasNotAssumingError);
-            if (notAssumingError) {
-                throw new NotAssumingError(notAssumingError.message)
+            const assumptionRequiredError = errors.find(hasAssumptionRequiredError);
+            if (assumptionRequiredError) {
+                throw new AssumptionRequiredError(assumptionRequiredError.message)
             }
 
             const unauthorizedError = errors.find(hasUnauthorizedError);
diff --git a/pkg/iam/authorizer.go b/pkg/iam/authorizer.go
index 67c8a91f7..60bd2525a 100644
--- a/pkg/iam/authorizer.go
+++ b/pkg/iam/authorizer.go
@@ -99,7 +99,7 @@ func (a *Authorizer) authorize(ctx context.Context, conn pg.Conn, params Authori
 			var errSessionExpired *ErrSessionExpired
 
 			if errors.As(err, &errSessionNotFound) || errors.As(err, &errSessionExpired) {
-				return NewAssumptionNeededError(params.Principal, membership.ID)
+				return NewAssumptionRequiredError(params.Principal, membership.ID)
 			}
 
 			return fmt.Errorf("cannot get active child session for membership: %w", err)
diff --git a/pkg/iam/errors.go b/pkg/iam/errors.go
index 314f1c998..057b6b934 100644
--- a/pkg/iam/errors.go
+++ b/pkg/iam/errors.go
@@ -183,17 +183,17 @@ func (e ErrInsufficientPermissions) Error() string {
 	return fmt.Sprintf("identity %q does not have sufficient permissions to perform action %s on entity %q", e.IdentityID, e.Action, e.EntityID)
 }
 
-type ErrAssumptionNeeded struct {
+type ErrAssumptionRequired struct {
 	IdentityID   gid.GID
 	MembershipID gid.GID
 }
 
-func NewAssumptionNeededError(identityID gid.GID, membershipID gid.GID) error {
-	return &ErrAssumptionNeeded{IdentityID: identityID, MembershipID: membershipID}
+func NewAssumptionRequiredError(identityID gid.GID, membershipID gid.GID) error {
+	return &ErrAssumptionRequired{IdentityID: identityID, MembershipID: membershipID}
 }
 
-func (e ErrAssumptionNeeded) Error() string {
-	return fmt.Sprintf("assumption for identity %q needed for membership %q", e.IdentityID, e.MembershipID)
+func (e ErrAssumptionRequired) Error() string {
+	return fmt.Sprintf("assumption for identity %q required for membership %q", e.IdentityID, e.MembershipID)
 }
 
 type ErrSessionNotFound struct{ SessionID gid.GID }
diff --git a/pkg/server/api/authz/authorization.go b/pkg/server/api/authz/authorization.go
index a2f270e3a..057591d2e 100644
--- a/pkg/server/api/authz/authorization.go
+++ b/pkg/server/api/authz/authorization.go
@@ -72,9 +72,9 @@ func NewAuthorizeFunc(
 		}
 
 		if err := svc.Authorizer.Authorize(ctx, params); err != nil {
-			var errAssumptionNeeded *iam.ErrAssumptionNeeded
-			if errors.As(err, &errAssumptionNeeded) {
-				return gqlutils.NotAssuming(ctx, err)
+			var errAssumptionRequired *iam.ErrAssumptionRequired
+			if errors.As(err, &errAssumptionRequired) {
+				return gqlutils.AssumptionRequired(ctx, err)
 			}
 
 			var errInsufficientPermissions *iam.ErrInsufficientPermissions
diff --git a/pkg/server/gqlutils/errors.go b/pkg/server/gqlutils/errors.go
index 24e5f3c6c..4f7307efd 100644
--- a/pkg/server/gqlutils/errors.go
+++ b/pkg/server/gqlutils/errors.go
@@ -52,18 +52,18 @@ func Unauthenticatedf(ctx context.Context, format string, a ...any) *gqlerror.Er
 	return Unauthenticated(ctx, fmt.Errorf(format, a...))
 }
 
-func NotAssuming(ctx context.Context, err error) *gqlerror.Error {
+func AssumptionRequired(ctx context.Context, err error) *gqlerror.Error {
 	return &gqlerror.Error{
 		Message: err.Error(),
 		Path:    graphql.GetPath(ctx),
 		Extensions: map[string]any{
-			"code": "NOT_ASSUMING",
+			"code": "ASSUMPTION_REQUIRED",
 		},
 	}
 }
 
-func NotAssumingf(ctx context.Context, format string, a ...any) *gqlerror.Error {
-	return NotAssuming(ctx, fmt.Errorf(format, a...))
+func AssumptionRequiredf(ctx context.Context, format string, a ...any) *gqlerror.Error {
+	return AssumptionRequired(ctx, fmt.Errorf(format, a...))
 }
 
 func Forbidden(ctx context.Context, err error) *gqlerror.Error {