diff --git a/src/main/ts/ActivationContext.ts b/src/main/ts/ActivationContext.ts
--- a/src/main/ts/ActivationContext.ts
+++ b/src/main/ts/ActivationContext.ts
@@ -29,7 +29,7 @@ export class ActivationContext<S> implem
 
     private readonly _service: Descriptor<S, unknown>;
 
-    private readonly _containerLifetimeManager: ILifetimeManager;
+    private readonly _lifetimeManagers: ILifetimeManager[];
 
     private readonly _parent: ActivationContext<S> | undefined;
 
@@ -41,12 +41,12 @@ export class ActivationContext<S> implem
      * @param service the service to activate, this parameter is used for the
      *  debug purpose.
      */
-    constructor(containerLifetimeManager: ILifetimeManager, services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
+    constructor(lifetimeManagers: ILifetimeManager[], services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
         this._name = name;
         this._service = service;
         this._cache = cache;
         this._services = services;
-        this._containerLifetimeManager = containerLifetimeManager;
+        this._lifetimeManagers = lifetimeManagers;
     }
 
     /** the name of the current resolving dependency */
@@ -54,10 +54,6 @@ export class ActivationContext<S> implem
         return this._name;
     }
 
-    createContainerLifetime<T>() {
-        return this._containerLifetimeManager.create<T>();
-    }
-
     resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
     resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
     resolve<K extends keyof S, T>(name: K, def?: T): NonNullable<S[K]> | T | undefined {
diff --git a/src/main/ts/Container.ts b/src/main/ts/Container.ts
--- a/src/main/ts/Container.ts
+++ b/src/main/ts/Container.ts
@@ -1,32 +1,22 @@
 import { ActivationContext } from "./ActivationContext";
 import { ActivationError } from "./ActivationError";
 import { ContainerBuilder } from "./ContainerBuilder";
+import { LifetimeManager } from "./LifetimeManager";
 import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ServiceLocator } from "./interfaces";
 
 export class Container<S> implements ServiceLocator<S>, IDestroyable {
     private readonly _services: DescriptorMap<S>;
 
-    private readonly _lifetimeManager: ILifetimeManager;
+    private readonly _lifetimeManagers: ILifetimeManager[];
 
     private _disposed: boolean;
 
     private readonly _onDestroyed: () => void;
 
-    constructor(services: DescriptorMap<S>, lifetimeManager: ILifetimeManager, destroyed: () => void) {
-        this._services = {
-            ...services,
-            container: {
-                configurable: false,
-                activate: () => this
-            },
-            childContainer: {
-                configurable: false,
-                activate: () => this.createChildBuilder(),
-            }
-        };
-
+    constructor(services: DescriptorMap<S>, lifetimeManagers: ILifetimeManager[], destroyed: () => void) {
+        this._services = services;
         this._disposed = false;
-        this._lifetimeManager = lifetimeManager;
+        this._lifetimeManagers = lifetimeManagers.concat(new LifetimeManager());
         this._onDestroyed = destroyed;
         
     }
@@ -56,7 +46,7 @@ export class Container<S> implements Ser
             else
                 throw new Error(`Service '${String(name)}' isn't found`);
         } else {
-            const context = new ActivationContext(this._lifetimeManager, this._services, String(name), d);
+            const context = new ActivationContext(this._lifetimeManagers, this._services, String(name), d);
             try {
                 return d.activate(context);
             } catch (error) {
diff --git a/src/main/ts/ContainerBuilder.ts b/src/main/ts/ContainerBuilder.ts
--- a/src/main/ts/ContainerBuilder.ts
+++ b/src/main/ts/ContainerBuilder.ts
@@ -1,25 +1,30 @@
 import { Container } from "./Container";
 import { DescriptorBuilder } from "./DescriptorBuilder";
-import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } from "./interfaces";
+import { containerSelfDescriptor } from "./DescriptorImpl";
+import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable, ContainerServices, ContainerServicesConstraint } from "./interfaces";
 import { emptyLifetime, LifetimeManager } from "./LifetimeManager";
 import { isDestroyable, prototype } from "./traits";
 
 /**
  * Container builder used to prepare service descriptors and create a IoC container
  */
-export class ContainerBuilder<S, U extends keyof S> implements
+export class ContainerBuilder<S extends ContainerServicesConstraint<S>, U extends keyof S> implements
     IContainerBuilder<S, U> {
 
     private _pending = 1;
 
-    private readonly _services: DescriptorMap<S>;
+    private readonly _services: DescriptorMap<ContainerServices<S>>;
 
     private readonly _lifetimeManager = new LifetimeManager();
 
     private readonly _lifetime: ILifetime<IDestroyable>;
 
     constructor(parentServices: DescriptorMap<S> | null = null, lifetime?: ILifetime<IDestroyable>) {
-        this._services = prototype(parentServices);
+        this._services = {
+            ...parentServices,
+            container: containerSelfDescriptor as any,
+            childContainer: containerSelfDescriptor as any
+        };
         this._lifetimeManager = new LifetimeManager();
         this._lifetime = lifetime ?? emptyLifetime();
     }
diff --git a/src/main/ts/DescriptorImpl.ts b/src/main/ts/DescriptorImpl.ts
--- a/src/main/ts/DescriptorImpl.ts
+++ b/src/main/ts/DescriptorImpl.ts
@@ -13,6 +13,13 @@ export interface DescriptorImplArgs<S, T
     dependencies?: DepsMap<S>;
 }
 
+export const containerSelfDescriptor = <S>() => Object.freeze({
+    level: 0,
+    activate(context: IActivationContext<S>) {
+        return context.createChildContainer();
+    }
+});
+
 
 export class DescriptorImpl<S, T> implements Descriptor<S, T> {
 
diff --git a/src/main/ts/LifetimeManager.ts b/src/main/ts/LifetimeManager.ts
--- a/src/main/ts/LifetimeManager.ts
+++ b/src/main/ts/LifetimeManager.ts
@@ -29,12 +29,10 @@ const _emptySlot = Object.freeze({
     cleanup: noop,
 });
 
-const _destroy = (item: IDestroyable) => item.destroy();
+const _destroy = (item: unknown) => () => isDestroyable(item) && item.destroy() ;
 
 const _makeCleanup = <T>(value: T, cleanup?: (item: T) => void) =>
-    cleanup ? () => cleanup(value) :
-        isDestroyable(value) ? () => _destroy(value) :
-            noop;
+    cleanup ? () => cleanup(value) : _destroy(value);
 
 const newSlot = <T>(put: (item: ILifetimeSlot<T>) => void, remove: () => void): ILifetimeSlot<T> => ({
     has: () => false,
@@ -119,6 +117,12 @@ export const emptyLifetime = <T>() => ()
 
 let nextId = 1;
 
+export const containerLifetime = <T>() => {
+    const slotId = nextId ++;
+    return (context: ILifetimeContext) =>
+        context.ownerSlot<T>(slotId);
+};
+
 export const hierarchyLifetime = <T>() => {
     const slotId = nextId++;
     return (context: ILifetimeContext) =>
diff --git a/src/main/ts/interfaces.ts b/src/main/ts/interfaces.ts
--- a/src/main/ts/interfaces.ts
+++ b/src/main/ts/interfaces.ts
@@ -1,3 +1,4 @@
+import { ContainerBuilder } from "./ContainerBuilder";
 import { key } from "./traits";
 
 export interface IDestroyable {
@@ -157,6 +158,10 @@ export type ContainerServicesConstraint<
 
 export interface Descriptor<S, T> {
 
+    /** The level of the service in the containers chain.
+    */
+    readonly level: number;
+
     /** This flags indicates that this registration can be replaced or overridden. */
     readonly configurable?: boolean;
 
@@ -170,6 +175,9 @@ export interface Descriptor<S, T> {
 
 /** The context used to initialize lifetime instance {@linkcode ILifetime} */
 export interface ILifetimeContext {
+
+    ownerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
+
     contextSlot<T>(slotId: string | number): ILifetimeSlot<T>;
 
     containerSlot<T>(slotId: string | number): ILifetimeSlot<T>;
@@ -181,6 +189,10 @@ export interface IActivationContext<S> e
     register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
 
     fail(error: unknown): never;
+
+    selfContainer(): ServiceLocator<S>;
+
+    createChildContainer(): IContainerBuilder<S, Exclude<keyof S, ContainerKeys>>;
 }
 
 /**
@@ -196,10 +208,10 @@ export type DescriptorMap<S> = {
 
 type ContainerKeys = keyof ContainerProvided<object>;
 
-export type ContainerProvided<S extends ContainerServicesConstraint<S>> = {
-    container: ServiceLocator<ContainerServices<S>>;
+export type ContainerProvided<S, U extends keyof S = keyof S> = {
+    container: ServiceLocator<ContainerProvided<S>>;
 
-    childContainer: IContainerBuilder<ContainerServices<S>, Exclude<keyof S, ContainerKeys>>;
+    childContainer: IContainerBuilder<S, U>;
 };
 
 
@@ -208,8 +220,8 @@ export type ContainerProvided<S extends 
  * 
  * Сервисы, предоставляемые контейнером не могут быть null или undefined.
  */
-export type ContainerServices<S extends ContainerServicesConstraint<S>> = {
-    [k in keyof S | ContainerKeys]:
+export type ContainerServices<S> = {
+    [k in (keyof S) | ContainerKeys]:
     k extends ContainerKeys ? ContainerProvided<S>[k] :
     k extends keyof S ? S[k] : never
 };
diff --git a/src/test/ts/t/container.ts b/src/test/ts/t/container.ts
--- a/src/test/ts/t/container.ts
+++ b/src/test/ts/t/container.ts
@@ -2,7 +2,7 @@
 import { describe, it } from "mocha";
 import { Container } from "../Container";
 import { ContainerBuilder } from "../ContainerBuilder";
-import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver } from "../interfaces";
+import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver, ServiceLocator } from "../interfaces";
 import { fluent } from "../traits";
 
 class Foo {
@@ -48,9 +48,9 @@ if (refs && refs.name === "foo") {
     refs.default;
 }
 
-declare const x: ContainerServices<Services>;
+declare const x: ServiceLocator<ContainerServices<Services>>;
 
-x.container.resolve("container");
+x.resolve("container").resolve("container");
 
 
 mmap({