diff --git a/packages/@ember/-internals/glimmer/index.ts b/packages/@ember/-internals/glimmer/index.ts
index abb5506b78f..e0ce66b3054 100644
--- a/packages/@ember/-internals/glimmer/index.ts
+++ b/packages/@ember/-internals/glimmer/index.ts
@@ -518,6 +518,8 @@ export {
   renderComponent,
   type View,
 } from './lib/renderer';
+// RFC #1200 -- render-tree-scoped context (provide/consume)
+export { createContext, type Context } from './lib/create-context';
 export {
   getTemplate,
   setTemplate,
diff --git a/packages/@ember/-internals/glimmer/lib/create-context.ts b/packages/@ember/-internals/glimmer/lib/create-context.ts
new file mode 100644
index 00000000000..1ef1487e823
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/create-context.ts
@@ -0,0 +1,194 @@
+/**
+ * @module @ember/helper
+ */
+import { precompileTemplate } from '@ember/template-compilation';
+import {
+  lookupRenderContext,
+  lookupRenderContextFor,
+  provideRenderContext,
+} from '@glimmer/runtime/lib/render-scope';
+import { valueForRef } from '@glimmer/reference/lib/reference';
+import InternalComponent, {
+  type OpaqueInternalComponentConstructor,
+  opaquify,
+} from './components/internal';
+
+/**
+ * The shape returned by `createContext`. Use `Provide` in templates to bind a
+ * value into the render tree, read `value` to get the nearest enclosing
+ * provided value, or call `consume(this)` to read it from a component
+ * instance's position in the render tree (e.g. in an event handler).
+ */
+export interface Context<T> {
+  Provide: OpaqueInternalComponentConstructor;
+  get value(): T;
+  consume(consumer?: object): T;
+}
+
+/**
+ * Creates a render-tree-scoped context per [RFC #1200][rfc].
+ *
+ * [rfc]: https://github.com/emberjs/rfcs/pull/1200
+ *
+ * `createContext` takes no value of its own -- it only establishes the
+ * *type* of the value (via a type parameter) and returns a `Provide`
+ * component plus a `value` getter. The value is supplied at render time
+ * through `<Provide @value={{...}}>`.
+ *
+ * @example
+ *
+ * ```gjs
+ * import { createContext } from '@ember/helper';
+ *
+ * class Theme {
+ *   color = 'dark';
+ * }
+ *
+ * const theme = createContext<Theme>();
+ *
+ * <template>
+ *   <theme.Provide @value={{this.theme}}>
+ *     {{theme.value.color}} {{! whatever this.theme.color is }}
+ *   </theme.Provide>
+ *
+ *   {{! Override the value at a nested provider: }}
+ *   <theme.Provide @value={{this.theme}}>
+ *     <theme.Provide @value={{this.lightTheme}}>
+ *       {{#let theme.value as |t|}}
+ *         {{t.color}} {{! the light theme's color }}
+ *       {{/let}}
+ *     </theme.Provide>
+ *   </theme.Provide>
+ *
+ *   {{theme.value}} {{! throws -- no provider in the hierarchy }}
+ * </template>
+ * ```
+ *
+ * Reactivity: the `@value` binding is reactive. When the argument passed to
+ * `<Provide>` updates, consumers re-render automatically. If `@value` is a
+ * stable object, mutating its `@tracked` fields likewise re-renders
+ * consumers.
+ *
+ * `value` throws if it is read outside of rendering, or if no matching
+ * `<Provide>` exists higher in the render tree. This is intentional
+ * harm-reduction: a missing provider is almost always a bug, not a
+ * legitimate "fall back to undefined" state. If you want a default, provide
+ * one at the application root.
+ *
+ * The returned object also has a `consume()` method. With no argument it
+ * behaves exactly like reading `value`. Passed a component instance, it
+ * resolves the context from that component's position in the render tree
+ * instead -- the way to read a context from event handlers and other code
+ * that runs outside of rendering:
+ *
+ * ```gjs
+ * import Component from '@glimmer/component';
+ * import { createContext } from '@ember/helper';
+ * import { on } from '@ember/modifier';
+ *
+ * const theme = createContext<Theme>();
+ *
+ * class ThemedButton extends Component {
+ *   onClick = () => {
+ *     // Outside of rendering, `theme.value` would throw -- but passing the
+ *     // component instance resolves the nearest <theme.Provide> above it.
+ *     console.log(theme.consume(this).color);
+ *   };
+ *
+ *   <template>
+ *     <button {{on 'click' this.onClick}}>{{yield}}</button>
+ *   </template>
+ * }
+ * ```
+ *
+ * Any rendered component instance works with every context -- the instance
+ * identifies a position in the render tree, not any one context's value.
+ * Resolution happens at `consume` time, so the value read is the provider's
+ * current `@value`, not a snapshot from render time.
+ *
+ * @method createContext
+ * @static
+ * @for @ember/helper
+ * @returns {Object} An object with `Provide` (a component that takes a
+ *   `@value`), `value` (a getter that reads the nearest provided value), and
+ *   `consume` (reads ambiently like `value`, or from a component instance's
+ *   position).
+ * @public
+ */
+export function createContext<T>(): Context<T> {
+  // This context's identity token: unique to this `createContext()` call and
+  // stable, so the matching `<Provide>` and `value` reads find each other on
+  // a shared render-scope node without colliding with other contexts. Held in
+  // the closure -- not exported.
+  const key = {};
+
+  class Provide extends InternalComponent {
+    static override toString(): string {
+      return 'Provide';
+    }
+
+    constructor(...args: ConstructorParameters<typeof InternalComponent>) {
+      super(...args);
+
+      // The provided value comes from `@value`. Store a lazy read that pulls
+      // the current value from the argument reference. `valueForRef` consumes
+      // tracking tags when called inside a tracking frame, so consumers
+      // re-render automatically when the argument updates. If `@value` was
+      // omitted, the provider still exists in the tree and provides
+      // `undefined` (`value` is undefined rather than throwing).
+      const valueRef = this.args.named['value'];
+      const read = (): unknown => (valueRef === undefined ? undefined : valueForRef(valueRef));
+
+      provideRenderContext(key, read);
+    }
+  }
+
+  // The ambient read backing both the `value` getter and a no-argument
+  // `consume()` call: resolve the nearest provider at the currently-rendering
+  // position.
+  function resolveAmbient(): T {
+    let read = lookupRenderContext(key);
+    if (read === undefined) {
+      throw new Error(
+        'A context `value` was read outside of rendering. The render-tree scope is only available during rendering -- there is nothing to read. To read a context from an event handler or other async callback, pass the component instance: `context.consume(this)`.'
+      );
+    }
+    if (read === null) {
+      throw new Error(
+        'No matching `<Provide>` was found in the render tree. Wrap consumers in `<Context.Provide @value={{...}}>...</Context.Provide>`, or provide a default at the application root.'
+      );
+    }
+    return read() as T;
+  }
+
+  return {
+    Provide: opaquify(Provide, PROVIDE_TEMPLATE),
+
+    get value(): T {
+      return resolveAmbient();
+    },
+
+    consume(consumer?: object): T {
+      if (consumer === undefined) {
+        return resolveAmbient();
+      }
+
+      let read = lookupRenderContextFor(consumer, key);
+      if (read === undefined) {
+        throw new Error(
+          '`consume(component)` expects a component instance that has been rendered -- the instance is how the context finds its position in the render tree. Pass the component itself (usually `this`), not another object, and only after the component has rendered.'
+        );
+      }
+      if (read === null) {
+        throw new Error(
+          'No matching `<Provide>` was found above the component passed to `consume`. Wrap the component in `<Context.Provide @value={{...}}>...</Context.Provide>`, or provide a default at the application root.'
+        );
+      }
+      return read() as T;
+    },
+  };
+}
+
+// All Provide components share the same template: yield to the block.
+// Per-instance behavior is parameterized via the closure in createContext.
+const PROVIDE_TEMPLATE = precompileTemplate('{{yield}}');
diff --git a/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts b/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts
new file mode 100644
index 00000000000..17b3ae4f592
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts
@@ -0,0 +1,1166 @@
+import {
+  AbstractStrictTestCase,
+  assertHTML,
+  buildOwner,
+  moduleFor,
+  runDestroy,
+} from 'internal-test-helpers';
+
+import { precompileTemplate } from '@ember/template-compilation';
+import { setComponentTemplate } from '@glimmer/manager';
+import templateOnly from '@ember/component/template-only';
+import GlimmerishComponent from '../utils/glimmerish-component';
+
+import { run } from '@ember/runloop';
+import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
+import { on } from '@ember/modifier';
+import { renderComponent } from '../../lib/renderer';
+import { createContext } from '../../lib/create-context';
+import { tracked } from '@glimmer/tracking';
+import type Owner from '@ember/owner';
+
+/**
+ * Coverage for `createContext` (the user-facing API discussed in
+ * https://github.com/emberjs/rfcs/pull/1200 -- NullVoxPopuli's
+ * `createContext` proposal returning `{ Provide, value }`).
+ *
+ * The API:
+ *
+ *   - `createContext<T>()` takes no value -- the type parameter declares the
+ *     shape, and the value is supplied at render time via `<Provide @value>`.
+ *   - `<myContext.Provide @value={{...}}>` provides a value to descendants.
+ *   - `{{myContext.value}}` (a template path) or `myContext.value` in JS
+ *     reads the nearest provided value; `value` is a getter.
+ *
+ * The substantive scenarios here are ported from
+ * `customerio/ember-provide-consume-context`'s test suite -- the prior-art
+ * implementation that NullVoxPopuli called out in the RFC -- to pin down the
+ * same behaviors production users rely on (sibling isolation, conditionals,
+ * reactivity to value changes, etc.). Where the two APIs intentionally
+ * diverge (EPCC's `getContext` returns `undefined` for missing context,
+ * whereas createContext throws per NVP's "reduce harm" clarification), the
+ * test asserts the createContext behavior.
+ */
+
+class CreateContextTestCase extends AbstractStrictTestCase {
+  owner: Owner;
+
+  constructor(assert: QUnit['assert']) {
+    super(assert);
+    this.owner = buildOwner({});
+    associateDestroyableChild(this, this.owner);
+  }
+
+  get element() {
+    return document.querySelector('#qunit-fixture')!;
+  }
+
+  renderComponent(component: object) {
+    let { owner } = this;
+    run(() => {
+      const result = renderComponent(component, {
+        owner,
+        env: { document: document, isInteractive: true, hasDOM: true },
+        into: this.element,
+      });
+      registerDestructor(this, () => result.destroy());
+    });
+  }
+}
+
+moduleFor(
+  'RFC #1200 -- createContext: smoke test',
+  class extends CreateContextTestCase {
+    afterEach() {
+      runDestroy(this);
+    }
+
+    '@test provide a value, consume it, and it renders'(assert: QUnit['assert']) {
+      class Theme {
+        color = 'dark';
+      }
+      const theme = createContext<Theme>();
+      const value = new Theme();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<theme.Provide @value={{value}}>{{#let theme.value as |t|}}<div id="content">{{t.color}}</div>{{/let}}</theme.Provide>',
+          {
+            strictMode: true,
+            scope: () => ({ theme, value }),
+          }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(
+        this.element.querySelector('#content')?.textContent,
+        'dark',
+        'consumer rendered the provided value'
+      );
+    }
+  }
+);
+
+moduleFor(
+  'RFC #1200 -- createContext: API surface',
+  class extends CreateContextTestCase {
+    afterEach() {
+      runDestroy(this);
+    }
+
+    '@test value throws if read outside of rendering'(assert: QUnit['assert']) {
+      const theme = createContext<{ color: string }>();
+
+      assert.throws(
+        () => theme.value,
+        /outside of rendering/,
+        'a value read outside a render is rejected'
+      );
+    }
+
+    '@test value throws when no <Provide> exists in the tree'(assert: QUnit['assert']) {
+      const theme = createContext<{ color: string }>();
+
+      let error: Error | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          try {
+            void theme.value;
+          } catch (e) {
+            error = e as Error;
+          }
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<Reader/>', {
+          strictMode: true,
+          scope: () => ({ Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+
+      assert.ok(error, 'the value read raised');
+      assert.ok(
+        /No matching `<Provide>`/.test(error?.message ?? ''),
+        `error mentions missing provider, got: ${error?.message}`
+      );
+    }
+
+    '@test context.value is usable as a template path'(assert: QUnit['assert']) {
+      const theme = createContext<{ color: string }>();
+      const value = { color: 'dark' };
+
+      // The getter composes with paths: both `{{theme.value.color}}` and
+      // going through a `{{#let}}` binding read the nearest provided value.
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<theme.Provide @value={{value}}>{{theme.value.color}}-{{#let theme.value as |t|}}{{t.color}}{{/let}}</theme.Provide>',
+          {
+            strictMode: true,
+            scope: () => ({ theme, value }),
+          }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assertHTML('dark-dark');
+      assert.ok(true);
+    }
+  }
+);
+
+/**
+ * The "real-world scenarios" suite, ported from
+ * ember-provide-consume-context's
+ * tests/integration/components/built-in-components-test.ts.
+ */
+moduleFor(
+  'RFC #1200 -- createContext: behavior ported from ember-provide-consume-context',
+  class extends CreateContextTestCase {
+    afterEach() {
+      runDestroy(this);
+    }
+
+    '@test a consumer can read context'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctx.Provide @value="5">{{#let ctx.value as |v|}}<div id="content">{{v}}</div>{{/let}}</ctx.Provide>',
+          { strictMode: true, scope: () => ({ ctx }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '5');
+    }
+
+    '@test a consumer reads from the closest provider'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<ctx.Provide @value="1">
+             {{#let ctx.value as |v|}}<div id="content-1">{{v}}</div>{{/let}}
+             <ctx.Provide @value="2">
+               {{#let ctx.value as |v|}}<div id="content-2">{{v}}</div>{{/let}}
+             </ctx.Provide>
+           </ctx.Provide>`,
+          { strictMode: true, scope: () => ({ ctx }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content-1')?.textContent, '1');
+      assert.strictEqual(this.element.querySelector('#content-2')?.textContent, '2');
+    }
+
+    "@test consumer's value updates when @value changes"(assert: QUnit['assert']) {
+      class State {
+        @tracked count = 1;
+      }
+      const state = new State();
+      const ctx = createContext<number>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctx.Provide @value={{state.count}}>{{#let ctx.value as |v|}}<div id="content">{{v}}</div>{{/let}}</ctx.Provide>',
+          { strictMode: true, scope: () => ({ ctx, state }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1');
+
+      run(() => {
+        state.count = 2;
+      });
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '2');
+    }
+
+    "@test a consumer can't access a context it isn't nested in"(assert: QUnit['assert']) {
+      const ctxA = createContext<string>();
+      const ctxB = createContext<string>();
+
+      let error: Error | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          try {
+            void ctxA.value;
+          } catch (e) {
+            error = e as Error;
+          }
+        }
+      }
+      setComponentTemplate(precompileTemplate('done'), Reader);
+
+      // Outer is ctxA (left subtree) and ctxB (right subtree); Reader is
+      // under ctxB, so a ctxA.value read should throw -- they don't bleed.
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctxA.Provide @value="A"></ctxA.Provide><ctxB.Provide @value="B"><Reader/></ctxB.Provide>',
+          { strictMode: true, scope: () => ({ ctxA, ctxB, Reader }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+
+      assert.ok(error, 'the value read raised for non-enclosing context');
+      assert.ok(
+        /No matching `<Provide>`/.test(error?.message ?? ''),
+        `error mentions missing provider, got: ${error?.message}`
+      );
+    }
+
+    '@test sibling Provides with the same context do not bleed'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<ctx.Provide @value="1">{{#let ctx.value as |v|}}<div id="content-1">{{v}}</div>{{/let}}</ctx.Provide>
+           <ctx.Provide @value="2">{{#let ctx.value as |v|}}<div id="content-2">{{v}}</div>{{/let}}</ctx.Provide>`,
+          { strictMode: true, scope: () => ({ ctx }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content-1')?.textContent, '1');
+      assert.strictEqual(this.element.querySelector('#content-2')?.textContent, '2');
+    }
+
+    '@test consumer is reactive across an {{#if}} that toggles it on and off'(
+      assert: QUnit['assert']
+    ) {
+      class State {
+        @tracked count = 1;
+        @tracked hidden = false;
+      }
+      const state = new State();
+      const ctx = createContext<number>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<ctx.Provide @value={{state.count}}>
+             {{#unless state.hidden}}
+               {{#let ctx.value as |v|}}<div id="content">{{v}}</div>{{/let}}
+             {{/unless}}
+           </ctx.Provide>`,
+          { strictMode: true, scope: () => ({ ctx, state }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1', 'initial');
+
+      run(() => {
+        state.hidden = true;
+      });
+      assert.strictEqual(this.element.querySelector('#content'), null, 'hidden');
+
+      run(() => {
+        state.hidden = false;
+      });
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1', 'back to "1"');
+
+      run(() => {
+        state.hidden = true;
+      });
+      run(() => {
+        state.count = 2;
+      });
+      run(() => {
+        state.hidden = false;
+      });
+      assert.strictEqual(
+        this.element.querySelector('#content')?.textContent,
+        '2',
+        'consumer reflects updated count when toggled back on'
+      );
+    }
+
+    '@test a conditional <Provide> tears down and re-instates correctly'(assert: QUnit['assert']) {
+      class State {
+        @tracked hidden = false;
+      }
+      const state = new State();
+      const ctx = createContext<string>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `{{#unless state.hidden}}
+             <ctx.Provide @value="1">{{#let ctx.value as |v|}}<div id="content">{{v}}</div>{{/let}}</ctx.Provide>
+           {{/unless}}`,
+          { strictMode: true, scope: () => ({ ctx, state }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1');
+
+      run(() => {
+        state.hidden = true;
+      });
+      assert.strictEqual(this.element.querySelector('#content'), null);
+
+      run(() => {
+        state.hidden = false;
+      });
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1');
+    }
+
+    '@test a conditional sibling <Provide> does not override an outer one'(
+      assert: QUnit['assert']
+    ) {
+      class State {
+        @tracked hidden = true;
+      }
+      const state = new State();
+      const ctx = createContext<string>();
+
+      // The inner ctx.Provide @value="2" is in a sibling subtree of the
+      // consumer, so it must never override the outer @value="1".
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<ctx.Provide @value="1">
+             {{#unless state.hidden}}
+               <ctx.Provide @value="2"></ctx.Provide>
+             {{/unless}}
+             {{#let ctx.value as |v|}}<div id="content">{{v}}</div>{{/let}}
+           </ctx.Provide>`,
+          { strictMode: true, scope: () => ({ ctx, state }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1');
+
+      run(() => {
+        state.hidden = false;
+      });
+      assert.strictEqual(
+        this.element.querySelector('#content')?.textContent,
+        '1',
+        'sibling provider does not override outer'
+      );
+
+      run(() => {
+        state.hidden = true;
+      });
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '1');
+    }
+
+    '@test multiple distinct contexts can be nested'(assert: QUnit['assert']) {
+      const ctxOne = createContext<string>();
+      const ctxTwo = createContext<string>();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<ctxOne.Provide @value="1">
+             <ctxTwo.Provide @value="2">
+               {{#let ctxOne.value as |a|}}<div id="content-1">{{a}}</div>{{/let}}
+               {{#let ctxTwo.value as |b|}}<div id="content-2">{{b}}</div>{{/let}}
+             </ctxTwo.Provide>
+           </ctxOne.Provide>`,
+          { strictMode: true, scope: () => ({ ctxOne, ctxTwo }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content-1')?.textContent, '1');
+      assert.strictEqual(this.element.querySelector('#content-2')?.textContent, '2');
+    }
+
+    '@test @tracked state on a provided class instance is reactive'(assert: QUnit['assert']) {
+      class Counter {
+        @tracked count = 0;
+      }
+      const counter = createContext<Counter>();
+      const instance = new Counter();
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<counter.Provide @value={{instance}}>{{#let counter.value as |c|}}<div id="content">{{c.count}}</div>{{/let}}</counter.Provide>',
+          { strictMode: true, scope: () => ({ counter, instance }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '0');
+
+      run(() => {
+        instance.count = 5;
+      });
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, '5');
+    }
+
+    '@test consumer at component-instance init time sees the nearest provider'(
+      assert: QUnit['assert']
+    ) {
+      // Mirrors EPCC's "a consumer can read context during initialization":
+      // when the consumer is a class component, its constructor should see
+      // the enclosing provider's value (not throw, not see a stale one).
+      const ctx = createContext<string>();
+
+      let observed: string | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observed = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate('done'), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<ctx.Provide @value="provided"><Reader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(observed, 'provided');
+    }
+
+    '@test a provided object identity is stable across the same Provide re-render'(
+      assert: QUnit['assert']
+    ) {
+      // Providing a stable object preserves identity. If a sibling tracked
+      // re-render happens, the same instance should be re-yielded -- not a
+      // new one. This matters for downstream code that uses identity (e.g.
+      // caching, refs).
+      class State {
+        @tracked tick = 0;
+      }
+      const state = new State();
+
+      const value = { id: 1 };
+      const ctx = createContext<{ id: number }>();
+
+      let observed: object[] = [];
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observed.push(ctx.value);
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          // The bare {{state.tick}} consumes the tracked tag so toggling it
+          // forces the surrounding region to re-render.
+          '<ctx.Provide @value={{value}}>{{state.tick}}<Reader/></ctx.Provide>',
+          { strictMode: true, scope: () => ({ ctx, state, value, Reader }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      const first = observed[0];
+      assert.strictEqual(first, value, 'reader observed the provided object');
+
+      run(() => {
+        state.tick = 1;
+      });
+
+      // Reader's constructor only fires once, so we don't get a second
+      // observed entry -- but the value it saw was the stable instance.
+      assert.strictEqual(observed.length, 1, 'reader constructed once');
+      assert.strictEqual(first, value, 'provided object identity is stable');
+    }
+  }
+);
+
+/**
+ * Extra-coverage suite for behaviors not exercised by the EPCC port:
+ *
+ * - a value read from a plain function helper
+ * - a value read from a modifier
+ * - explicit @value={{undefined}} / @value={{null}}, and omitting @value
+ * - cross-renderComponent isolation
+ * - multiple value reads in the same template return the same identity
+ */
+import { defineSimpleHelper, defineSimpleModifier } from 'internal-test-helpers';
+
+moduleFor(
+  'RFC #1200 -- createContext: extra coverage',
+  class extends CreateContextTestCase {
+    afterEach() {
+      runDestroy(this);
+    }
+
+    '@test value works inside a plain function helper'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      // A genuine helper -- not just `ctx.value` in a let-binding.
+      // This exercises that value can be read from a function whose
+      // identity is wrapped by the helper manager, which the RFC explicitly
+      // allows ("in a plain function helper's body").
+      const readContext = defineSimpleHelper(() => ctx.value);
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctx.Provide @value="from-helper"><div id="content">{{(readContext)}}</div></ctx.Provide>',
+          { strictMode: true, scope: () => ({ ctx, readContext }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(this.element.querySelector('#content')?.textContent, 'from-helper');
+    }
+
+    '@test KNOWN LIMITATION: a value read inside a modifier install throws'(
+      assert: QUnit['assert']
+    ) {
+      // Modifier install runs during `transaction.commit()`, which fires
+      // *after* the render frame has popped its scope stack. So reading
+      // value inside a modifier callback sees an empty scope and throws
+      // "outside of rendering".
+      //
+      // This pins down the current behavior so a future fix (e.g. wrapping
+      // modifier install in the enclosing component's scope) doesn't break
+      // silently. RFC #1200 documents this limitation explicitly.
+      const ctx = createContext<string>();
+
+      let caught: Error | undefined;
+      const stash = defineSimpleModifier((_element: Element) => {
+        try {
+          void ctx.value;
+        } catch (e) {
+          caught = e as Error;
+        }
+      });
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctx.Provide @value="from-modifier"><div {{stash}}>x</div></ctx.Provide>',
+          { strictMode: true, scope: () => ({ ctx, stash }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.ok(caught, 'the value read in modifier install threw');
+      assert.ok(
+        /outside of rendering/.test(caught?.message ?? ''),
+        `error mentions outside-of-rendering, got: ${caught?.message}`
+      );
+    }
+
+    '@test explicit @value={{undefined}} provides undefined (not "no provider")'(
+      assert: QUnit['assert']
+    ) {
+      const ctx = createContext<string | undefined>();
+
+      let observed: unknown = 'NOT_SET';
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observed = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      // Explicit @value=undefined -- the consumer should see undefined,
+      // NOT throw "no provider" (the Provide *is* in the tree, it just
+      // chose to provide an undefined value).
+      let Root = setComponentTemplate(
+        precompileTemplate('<ctx.Provide @value={{undefined}}><Reader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(observed, undefined, 'consumer saw the explicit undefined value');
+    }
+
+    '@test omitting @value provides undefined (not "no provider")'(assert: QUnit['assert']) {
+      const ctx = createContext<string | undefined>();
+
+      let observed: unknown = 'NOT_SET';
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observed = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      // No @value at all -- the Provide is still in the tree, so value
+      // is undefined rather than throwing.
+      let Root = setComponentTemplate(
+        precompileTemplate('<ctx.Provide><Reader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(observed, undefined, 'consumer saw undefined when @value omitted');
+    }
+
+    '@test explicit @value={{null}} provides null'(assert: QUnit['assert']) {
+      const ctx = createContext<string | null>();
+
+      let observed: unknown = 'NOT_SET';
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observed = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<ctx.Provide @value={{null}}><Reader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(observed, null, 'consumer saw the explicit null value');
+    }
+
+    '@test multiple value reads in the same template return the same identity'(
+      assert: QUnit['assert']
+    ) {
+      // Each value read walks up the scope chain. They should both find the
+      // same provider entry and return the same value -- strict-equal
+      // identity for a provided object.
+      class State {
+        marker = Symbol('state');
+      }
+      const ctx = createContext<State>();
+      const instance = new State();
+
+      let firstSeen: State | undefined;
+      let secondSeen: State | undefined;
+      class FirstReader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          firstSeen = ctx.value;
+        }
+      }
+      class SecondReader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          secondSeen = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), FirstReader);
+      setComponentTemplate(precompileTemplate(''), SecondReader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctx.Provide @value={{instance}}><FirstReader/><SecondReader/></ctx.Provide>',
+          {
+            strictMode: true,
+            scope: () => ({ ctx, instance, FirstReader, SecondReader }),
+          }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.ok(firstSeen, 'first reader observed');
+      assert.ok(secondSeen, 'second reader observed');
+      assert.strictEqual(firstSeen, secondSeen, 'both consumers see the same instance');
+    }
+
+    '@test a value read works across {{#in-element}}'(assert: QUnit['assert']) {
+      // {{#in-element}} moves where the DOM lands, not where the block sits
+      // in the render tree. Scoping follows the render tree, so a consumer
+      // portaled into an unrelated element still sees the provider that
+      // encloses it in the template -- even though, in the DOM, its output
+      // lands outside the provider's, in the sibling div above it.
+      const ctx = createContext<string>();
+
+      let observedInConstructor: string | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observedInConstructor = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      const findPortal = defineSimpleHelper(() => document.querySelector('#portal-target'));
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<div id="portal-target"></div>
+           <ctx.Provide @value="through-the-portal">
+             {{#in-element (findPortal)}}
+               {{#let ctx.value as |v|}}<div id="content">{{v}}</div>{{/let}}
+               <Reader/>
+             {{/in-element}}
+           </ctx.Provide>`,
+          { strictMode: true, scope: () => ({ ctx, findPortal, Reader }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(
+        this.element.querySelector('#portal-target #content')?.textContent,
+        'through-the-portal',
+        'template path read inside the portal saw the outside provider'
+      );
+      assert.strictEqual(
+        observedInConstructor,
+        'through-the-portal',
+        'component constructor inside the portal saw the outside provider'
+      );
+    }
+  }
+);
+
+/**
+ * Independent renderComponent trees must not share scope state. This sits
+ * in its own module so each test's `renderComponent` call is independent
+ * (the base class wires `into: #qunit-fixture`, so we render two trees
+ * into separate sub-elements within the same fixture).
+ */
+moduleFor(
+  'RFC #1200 -- createContext: cross-renderComponent isolation',
+  class extends CreateContextTestCase {
+    afterEach() {
+      runDestroy(this);
+    }
+
+    "@test separate renderComponent calls do not see each other's providers"(
+      assert: QUnit['assert']
+    ) {
+      const ctx = createContext<string>();
+
+      let bareError: Error | undefined;
+      class BareReader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          try {
+            void ctx.value;
+          } catch (e) {
+            bareError = e as Error;
+          }
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), BareReader);
+
+      let providedSeen: string | undefined;
+      class ProvidedReader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          providedSeen = ctx.value;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), ProvidedReader);
+
+      // Two independent component trees, both rendered into the fixture
+      // but in separate `renderComponent` calls. The first has no
+      // <Provide>; the second is wrapped in one. The presence of a
+      // <Provide> in tree #2 must not bleed into tree #1.
+      const fixture = this.element;
+      const slotA = document.createElement('div');
+      const slotB = document.createElement('div');
+      fixture.appendChild(slotA);
+      fixture.appendChild(slotB);
+
+      let TreeA = setComponentTemplate(
+        precompileTemplate('<BareReader/>', {
+          strictMode: true,
+          scope: () => ({ BareReader }),
+        }),
+        templateOnly()
+      );
+      let TreeB = setComponentTemplate(
+        precompileTemplate('<ctx.Provide @value="B"><ProvidedReader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, ProvidedReader }),
+        }),
+        templateOnly()
+      );
+
+      run(() => {
+        const { owner } = this;
+        const a = renderComponent(TreeA, {
+          owner,
+          env: { document, isInteractive: true, hasDOM: true },
+          into: slotA,
+        });
+        const b = renderComponent(TreeB, {
+          owner,
+          env: { document, isInteractive: true, hasDOM: true },
+          into: slotB,
+        });
+        registerDestructor(this, () => {
+          a.destroy();
+          b.destroy();
+        });
+      });
+
+      assert.ok(bareError, 'tree A: no provider, the value read threw');
+      assert.ok(
+        /No matching `<Provide>`/.test(bareError?.message ?? ''),
+        `error mentions missing provider, got: ${bareError?.message}`
+      );
+      assert.strictEqual(providedSeen, 'B', 'tree B: own <Provide @value="B"> visible');
+    }
+  }
+);
+
+/**
+ * Coverage for `consume()`:
+ *
+ * - `consume()` with no argument behaves exactly like reading `value`
+ *   (same result, same error cases).
+ * - `consume(componentInstance)` resolves the context from that component's
+ *   position in the render tree, *outside* of rendering (the event-handler
+ *   use case). The instance -> render-node association is made by the VM
+ *   when the component renders -- an implementation detail; user code just
+ *   passes `this`.
+ */
+moduleFor(
+  'RFC #1200 -- createContext: consume()',
+  class extends CreateContextTestCase {
+    afterEach() {
+      runDestroy(this);
+    }
+
+    '@test consume() with no argument reads like value'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      let observed: string | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          observed = ctx.consume();
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<ctx.Provide @value="ambient"><Reader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(observed, 'ambient', 'consume() saw the provided value');
+    }
+
+    '@test consume() with no argument throws outside of rendering'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      assert.throws(
+        () => ctx.consume(),
+        /outside of rendering/,
+        'an ambient consume() outside a render is rejected'
+      );
+    }
+
+    '@test consume() with no argument throws when no <Provide> exists'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      let error: Error | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          try {
+            ctx.consume();
+          } catch (e) {
+            error = e as Error;
+          }
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<Reader/>', { strictMode: true, scope: () => ({ Reader }) }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.ok(
+        /No matching `<Provide>`/.test(error?.message ?? ''),
+        `error mentions missing provider, got: ${error?.message}`
+      );
+    }
+
+    '@test consume(this) resolves the context from an event handler'(assert: QUnit['assert']) {
+      const theme = createContext<{ color: string }>();
+      const value = { color: 'rebeccapurple' };
+
+      let observed: { color: string } | undefined;
+      let ambientError: Error | undefined;
+      class Button extends GlimmerishComponent {
+        onClick = () => {
+          // Prove we really are outside of rendering: the ambient read throws...
+          try {
+            void theme.value;
+          } catch (e) {
+            ambientError = e as Error;
+          }
+          // ...but the component instance's position still resolves.
+          observed = theme.consume(this);
+        };
+      }
+      setComponentTemplate(
+        precompileTemplate('<button type="button" {{on "click" this.onClick}}>go</button>', {
+          strictMode: true,
+          scope: () => ({ on }),
+        }),
+        Button
+      );
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<theme.Provide @value={{value}}><Button/></theme.Provide>', {
+          strictMode: true,
+          scope: () => ({ theme, value, Button }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      this.element.querySelector('button')!.click();
+
+      assert.ok(
+        /outside of rendering/.test(ambientError?.message ?? ''),
+        'the ambient value read in the handler threw (we were outside of rendering)'
+      );
+      assert.strictEqual(observed, value, 'consume(this) resolved the provided value');
+    }
+
+    '@test consume(this) resolves the nearest provider above each component'(
+      assert: QUnit['assert']
+    ) {
+      const ctx = createContext<string>();
+
+      let innerInstance: object | undefined;
+      let outerInstance: object | undefined;
+      class InnerReader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          innerInstance = this;
+        }
+      }
+      class OuterReader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          outerInstance = this;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), InnerReader);
+      setComponentTemplate(precompileTemplate(''), OuterReader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          `<ctx.Provide @value="outer">
+             <OuterReader/>
+             <ctx.Provide @value="inner">
+               <InnerReader/>
+             </ctx.Provide>
+           </ctx.Provide>`,
+          { strictMode: true, scope: () => ({ ctx, InnerReader, OuterReader }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+
+      // Both resolutions happen here, after the render stack has unwound.
+      assert.strictEqual(ctx.consume(outerInstance!), 'outer', 'outer component sees "outer"');
+      assert.strictEqual(ctx.consume(innerInstance!), 'inner', 'inner component sees "inner"');
+    }
+
+    '@test one component instance works with every context'(assert: QUnit['assert']) {
+      const ctxA = createContext<string>();
+      const ctxB = createContext<string>();
+
+      let instance: object | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          instance = this;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate(
+          '<ctxA.Provide @value="A"><ctxB.Provide @value="B"><Reader/></ctxB.Provide></ctxA.Provide>',
+          { strictMode: true, scope: () => ({ ctxA, ctxB, Reader }) }
+        ),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+
+      assert.strictEqual(ctxA.consume(instance!), 'A', 'the instance resolves ctxA');
+      assert.strictEqual(ctxB.consume(instance!), 'B', 'the same instance resolves ctxB');
+    }
+
+    '@test consume(this) reads the current @value, not a snapshot'(assert: QUnit['assert']) {
+      class State {
+        @tracked count = 1;
+      }
+      const state = new State();
+      const ctx = createContext<number>();
+
+      let instance: object | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          instance = this;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<ctx.Provide @value={{state.count}}><Reader/></ctx.Provide>', {
+          strictMode: true,
+          scope: () => ({ ctx, state, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+      assert.strictEqual(ctx.consume(instance!), 1, 'initial value');
+
+      run(() => {
+        state.count = 2;
+      });
+      assert.strictEqual(ctx.consume(instance!), 2, 'resolution reflects the updated @value');
+    }
+
+    '@test consume(this) throws when no provider exists above the component'(
+      assert: QUnit['assert']
+    ) {
+      const provided = createContext<string>();
+      const missing = createContext<string>();
+
+      let instance: object | undefined;
+      class Reader extends GlimmerishComponent {
+        constructor(owner: Owner, args: Record<string, unknown>) {
+          super(owner, args);
+          instance = this;
+        }
+      }
+      setComponentTemplate(precompileTemplate(''), Reader);
+
+      let Root = setComponentTemplate(
+        precompileTemplate('<provided.Provide @value="here"><Reader/></provided.Provide>', {
+          strictMode: true,
+          scope: () => ({ provided, Reader }),
+        }),
+        templateOnly()
+      );
+
+      this.renderComponent(Root);
+
+      assert.strictEqual(provided.consume(instance!), 'here', 'sanity: the instance is known');
+      assert.throws(
+        () => missing.consume(instance!),
+        /No matching `<Provide>` was found above the component/,
+        'a context with no provider above the component is rejected'
+      );
+    }
+
+    '@test consume(component) rejects an object that never rendered'(assert: QUnit['assert']) {
+      const ctx = createContext<string>();
+
+      assert.throws(
+        () => ctx.consume({}),
+        /expects a component instance that has been rendered/,
+        'an arbitrary object is not accepted'
+      );
+    }
+  }
+);
diff --git a/packages/@ember/helper/index.ts b/packages/@ember/helper/index.ts
index 110d9c5916e..9bd4b1b1de3 100644
--- a/packages/@ember/helper/index.ts
+++ b/packages/@ember/helper/index.ts
@@ -711,3 +711,82 @@ export const not = glimmerNot as unknown as NotHelper;
 export interface NotHelper extends Opaque<'helper:not'> {}
 
 /* eslint-enable @typescript-eslint/no-empty-object-type */
+
+/**
+ * Creates a render-tree-scoped context (provide/consume) for sharing values
+ * with descendant components without prop drilling.
+ *
+ * See [RFC #1200](https://github.com/emberjs/rfcs/pull/1200) and the original
+ * [Context RFC #975](https://github.com/emberjs/rfcs/pull/975).
+ *
+ * `createContext` takes no value of its own — it only establishes the *type*
+ * of the value (via a type parameter) and returns an object with:
+ *
+ * - `Provide`: a component that exposes its `@value` argument to every
+ *    descendant in the block.
+ * - `value`: a getter (also usable as a template path) that returns the
+ *    nearest enclosing provided value. **Throws** if there is no matching
+ *    provider higher in the render tree, or if read outside of rendering.
+ * - `consume`: with no argument, identical to reading `value`. Passed a
+ *    component instance, it resolves the context from that component's
+ *    position in the render tree instead -- the way to read a context from
+ *    event handlers and other code that runs outside of rendering.
+ *
+ * ```gjs
+ * import { createContext } from '@ember/helper';
+ *
+ * class Theme {
+ *   color = 'dark';
+ * }
+ *
+ * const theme = createContext<Theme>();
+ *
+ * <template>
+ *   <theme.Provide @value={{this.theme}}>
+ *     {{theme.value.color}}
+ *   </theme.Provide>
+ *
+ *   {{theme.value}} {{! throws -- no provider }}
+ * </template>
+ * ```
+ *
+ * Reactivity: the `@value` binding is reactive. When the argument updates,
+ * consumers re-render; mutating `@tracked` fields on a stable provided
+ * object likewise invalidates consumers.
+ *
+ * Reading a context from an event handler (or any other code that runs
+ * outside of rendering, where the ambient `value` read throws) works by
+ * passing the component instance to `consume` — the instance identifies the
+ * component's position in the render tree:
+ *
+ * ```gjs
+ * import Component from '@glimmer/component';
+ * import { createContext } from '@ember/helper';
+ * import { on } from '@ember/modifier';
+ *
+ * const theme = createContext<Theme>();
+ *
+ * class ThemedButton extends Component {
+ *   onClick = () => {
+ *     console.log(theme.consume(this).color);
+ *   };
+ *
+ *   <template>
+ *     <button {{on 'click' this.onClick}}>{{yield}}</button>
+ *   </template>
+ * }
+ * ```
+ *
+ * Any rendered component instance works with every context, and resolution
+ * happens at `consume` time — the value read is the provider's current
+ * `@value`, not a snapshot from render time.
+ *
+ * @method createContext
+ * @static
+ * @for @ember/helper
+ * @returns {Object} `{ Provide, value, consume }`
+ * @public
+ */
+export { createContext } from '@ember/-internals/glimmer/lib/create-context';
+
+export type { Context } from '@ember/-internals/glimmer/lib/create-context';
diff --git a/packages/@glimmer/interfaces/lib/runtime/environment.d.ts b/packages/@glimmer/interfaces/lib/runtime/environment.d.ts
index c47f1c98abb..6d692a8c04a 100644
--- a/packages/@glimmer/interfaces/lib/runtime/environment.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/environment.d.ts
@@ -47,10 +47,21 @@ export interface Environment {
 
   isInteractive: boolean;
   debugRenderTree?: DebugRenderTree | undefined;
+  // Render-tree scope tracker backing `createContext` (RFC #1200). Unlike
+  // debugRenderTree this is always present, because it backs a real feature.
+  // Only the render-node lifecycle is part of this interface; provide/lookup
+  // happen through the module-level helpers in `@glimmer/runtime`.
+  renderScope: RenderScopeTracker;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   isArgumentCaptureError?: ((error: any) => boolean) | undefined;
 }
 
+export interface RenderScopeTracker {
+  create(bucket: object): void;
+  enter(bucket: object): void;
+  exit(): void;
+}
+
 export interface RuntimeOptions {
   readonly env: Environment;
   readonly program: Program;
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
index ec5b2c206d1..0a86cb75a7e 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
@@ -103,6 +103,7 @@ import {
   CheckReference,
 } from './-debug-strip';
 import { UpdateDynamicAttributeOpcode } from './dom';
+import { associateRenderScope } from '../../render-scope';
 
 /**
  * The VM creates a new ComponentInstance data structure for every component
@@ -387,6 +388,14 @@ APPEND_OPCODES.add(VM_CREATE_COMPONENT_OP, (vm, { op1: flags }) => {
   let instance = check(vm.fetchValue($s0), CheckComponentInstance);
   let { definition, manager, capabilities } = instance;
 
+  // RFC #1154 -- push this component's render-tree scope before the user-land
+  // constructor runs, so that provide/consume (createContext) inside the
+  // constructor see the new scope (and its parent chain). Always-on. Mirroring
+  // debugRenderTree would be too late: the user constructor runs in
+  // manager.create() below.
+  vm.env.renderScope.create(instance);
+  vm.updateWith(new RenderScopeUpdateOpcode(instance));
+
   if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.createInstance)) {
     // TODO: Closure and Main components are always invoked dynamically, so this
     // opcode may run even if this capability is not enabled. In the future we
@@ -657,6 +666,20 @@ APPEND_OPCODES.add(VM_GET_COMPONENT_SELF_OP, (vm, { op1: register, op2: _names }
   let { manager } = definition;
   let selfRef = manager.getSelf(state);
 
+  // RFC #1200 -- associate the user-facing component instance with this
+  // component's render-scope node, so `context.consume(this)` can resolve
+  // contexts from event handlers and other code that runs after the render
+  // stack has unwound. Component self refs are const refs wrapping the
+  // instance, so the eager read consumes no tracking tags; template-only
+  // components have a NULL_REFERENCE self and are skipped (there is no
+  // instance for user code to pass).
+  if (isConstRef(selfRef)) {
+    let self: unknown = valueForRef(selfRef);
+    if (self !== null && typeof self === 'object') {
+      associateRenderScope(self);
+    }
+  }
+
   if (vm.env.debugRenderTree !== undefined) {
     let instance = check(vm.fetchValue(check(register, CheckRegister)), CheckComponentInstance);
     let { definition, manager } = instance;
@@ -889,6 +912,12 @@ APPEND_OPCODES.add(VM_DID_RENDER_LAYOUT_OP, (vm, { op1: register }) => {
   let { manager, state, capabilities } = instance;
   let bounds = vm.tree().popBlock();
 
+  // RFC #1154 -- pop the render scope stack to match the create() done in
+  // VM_CREATE_COMPONENT_OP. This must happen unconditionally and outside
+  // the debugRenderTree branch below.
+  vm.env.renderScope.exit();
+  vm.updateWith(new RenderScopeExitOpcode());
+
   if (vm.env.debugRenderTree !== undefined) {
     if (hasCustomDebugRenderTreeLifecycle(manager)) {
       let nodes = manager.getDebugCustomRenderTree(instance.definition.state, state, EMPTY_ARGS);
@@ -970,3 +999,21 @@ class DebugRenderTreeDidRenderOpcode implements UpdatingOpcode {
     vm.env.debugRenderTree?.didRender(this.bucket, this.bounds);
   }
 }
+
+// RFC #1154 -- render-tree scope lifecycle during updating frames. We have to
+// push the render node back onto the scope stack at the start of its update
+// and pop it back off at the end, so that any descendants which read a
+// context `value` during their own update see the correct parent chain.
+class RenderScopeUpdateOpcode implements UpdatingOpcode {
+  constructor(private bucket: object) {}
+
+  evaluate(vm: UpdatingVM) {
+    vm.env.renderScope.enter(this.bucket);
+  }
+}
+
+class RenderScopeExitOpcode implements UpdatingOpcode {
+  evaluate(vm: UpdatingVM) {
+    vm.env.renderScope.exit();
+  }
+}
diff --git a/packages/@glimmer/runtime/lib/environment.ts b/packages/@glimmer/runtime/lib/environment.ts
index bafbefe2f82..2544d58f05a 100644
--- a/packages/@glimmer/runtime/lib/environment.ts
+++ b/packages/@glimmer/runtime/lib/environment.ts
@@ -21,6 +21,7 @@ import { UPDATE_TAG as updateTag } from '@glimmer/validator/lib/validators';
 
 import DebugRenderTree from './debug-render-tree';
 import { DOMChangesImpl, DOMTreeConstruction } from './dom/helper';
+import { RenderScopeTracker, setCurrentRenderScopeTracker } from './render-scope';
 import { isArgumentError } from './vm/arguments';
 
 export const TRANSACTION: TransactionSymbol = Symbol('TRANSACTION') as TransactionSymbol;
@@ -108,6 +109,7 @@ export class EnvironmentImpl implements Environment {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   isArgumentCaptureError: ((error: any) => boolean) | undefined;
   debugRenderTree: DebugRenderTree<object> | undefined;
+  renderScope: RenderScopeTracker = new RenderScopeTracker();
 
   constructor(
     options: EnvironmentOptions,
@@ -145,6 +147,8 @@ export class EnvironmentImpl implements Environment {
     );
 
     this.debugRenderTree?.begin();
+    this.renderScope.begin();
+    setCurrentRenderScopeTracker(this.renderScope);
 
     this[TRANSACTION] = new TransactionImpl();
   }
@@ -179,6 +183,7 @@ export class EnvironmentImpl implements Environment {
     transaction.commit();
 
     this.debugRenderTree?.commit();
+    setCurrentRenderScopeTracker(undefined);
 
     this.delegate.onTransactionCommit();
   }
diff --git a/packages/@glimmer/runtime/lib/render-scope.ts b/packages/@glimmer/runtime/lib/render-scope.ts
new file mode 100644
index 00000000000..1e56cda603b
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/render-scope.ts
@@ -0,0 +1,155 @@
+import type { Nullable } from '@glimmer/interfaces';
+import { StackImpl as Stack } from '@glimmer/util/lib/collections';
+
+// createContext (RFC #1200) is the only consumer. A `read` returns the
+// currently-provided value for a context key, evaluated lazily so that
+// auto-tracking inside it makes consumers reactive to the provided `@value`.
+type ContextRead = () => unknown;
+
+interface RenderScopeNode {
+  parent: Nullable<RenderScopeNode>;
+  // key -> read, lazily allocated (most render nodes never provide a context).
+  contexts: Nullable<Map<object, ContextRead>>;
+}
+
+/**
+ * Tracks the render-tree node hierarchy so a consumer can find the nearest
+ * provider above it. Mirrors `DebugRenderTree`'s stack management, but is
+ * always-on because it backs a real feature.
+ */
+export class RenderScopeTracker {
+  private stack = new Stack<RenderScopeNode>();
+  // bucket (component instance) -> node, so updating frames can re-push it.
+  private nodes = new WeakMap<object, RenderScopeNode>();
+
+  // Drop any nodes left on the stack by a render that errored mid-flight.
+  begin(): void {
+    while (!this.stack.isEmpty()) {
+      this.stack.pop();
+    }
+  }
+
+  // Push a fresh node when a component is created (before its constructor runs).
+  create(bucket: object): void {
+    let node: RenderScopeNode = { parent: this.stack.current ?? null, contexts: null };
+    this.nodes.set(bucket, node);
+    this.stack.push(node);
+  }
+
+  // Re-push an existing node when its component re-renders.
+  enter(bucket: object): void {
+    let node = this.nodes.get(bucket);
+    if (node !== undefined) {
+      this.stack.push(node);
+    }
+  }
+
+  exit(): void {
+    this.stack.pop();
+  }
+
+  // Provide `key`'s value at the current node (called from `<Provide>`, which is
+  // always the rendering node, so `current` is guaranteed to be set).
+  provide(key: object, read: ContextRead): void {
+    let node = this.stack.current;
+    if (node) {
+      (node.contexts ??= new Map()).set(key, read);
+    }
+  }
+
+  // The nearest provider of `key`:
+  //   `undefined` -> not inside a render frame (e.g. a modifier installing
+  //                  during commit, after the render stack has unwound),
+  //   `null`      -> inside a frame, but no provider for `key`,
+  //   a function  -> the nearest provider's read fn.
+  lookup(key: object): ContextRead | null | undefined {
+    let current = this.stack.current;
+    if (current === null) {
+      return undefined;
+    }
+    return lookupInChain(current, key);
+  }
+
+  // The node currently being rendered, for `captureRenderScope`. `null`
+  // outside a render frame.
+  capture(): Nullable<RenderScopeNode> {
+    return this.stack.current;
+  }
+}
+
+// Walk `start` and its ancestors for the nearest provider of `key`.
+function lookupInChain(start: RenderScopeNode, key: object): ContextRead | null {
+  for (let node: Nullable<RenderScopeNode> = start; node !== null; node = node.parent) {
+    let read = node.contexts?.get(key);
+    if (read !== undefined) {
+      return read;
+    }
+  }
+  return null;
+}
+
+// The renderer points this at the active tracker for the duration of a render,
+// so the helpers below work from anywhere in a tick (e.g. a context `value`
+// read that has no handle to the VM). Cleared between renders.
+let CURRENT: RenderScopeTracker | undefined;
+
+export function setCurrentRenderScopeTracker(tracker: RenderScopeTracker | undefined): void {
+  CURRENT = tracker;
+}
+
+/** Provide `key`'s value at the current render node (createContext's `<Provide>`). */
+export function provideRenderContext(key: object, read: ContextRead): void {
+  if (CURRENT === undefined) {
+    throw new Error('A context can only be provided while rendering.');
+  }
+  CURRENT.provide(key, read);
+}
+
+/**
+ * The nearest provider of `key`:
+ *   `undefined` -> called outside of rendering,
+ *   `null`      -> rendering, but no provider for `key`,
+ *   a function  -> the nearest provider's read fn.
+ */
+export function lookupRenderContext(key: object): ContextRead | null | undefined {
+  return CURRENT === undefined ? undefined : CURRENT.lookup(key);
+}
+
+// user-facing component instance -> its render-scope node. Populated by the
+// VM when a component's `self` becomes known (VM_GET_COMPONENT_SELF_OP), so
+// `context.consume(this)` can resolve contexts after the render stack has
+// unwound. The association -- and the provider chain above the node -- lives
+// exactly as long as the instance itself.
+const ASSOCIATED_NODES = new WeakMap<object, RenderScopeNode>();
+
+/**
+ * Associate a user-facing component instance with the currently-rendering
+ * node, making the instance usable with `lookupRenderContextFor` later. A
+ * no-op outside of a render frame (there is no node to associate with).
+ */
+export function associateRenderScope(instance: object): void {
+  let node = CURRENT === undefined ? null : CURRENT.capture();
+  if (node !== null) {
+    ASSOCIATED_NODES.set(instance, node);
+  }
+}
+
+/**
+ * The nearest provider of `key` above `instance`'s position in the render
+ * tree:
+ *   `undefined` -> `instance` has no associated render-scope node (it is not
+ *                  a component instance, or it has not rendered),
+ *   `null`      -> a known instance, but no provider for `key` above it,
+ *   a function  -> the nearest provider's read fn.
+ *
+ * Unlike `lookupRenderContext` this works outside of rendering -- that is the
+ * point: event handlers and other async callbacks run after the render stack
+ * has unwound, so the ambient lookup has nothing to see.
+ */
+export function lookupRenderContextFor(
+  instance: object,
+  key: object
+): ContextRead | null | undefined {
+  let node = ASSOCIATED_NODES.get(instance);
+  return node === undefined ? undefined : lookupInChain(node, key);
+}
diff --git a/smoke-tests/scenarios/basic-test.ts b/smoke-tests/scenarios/basic-test.ts
index dbe3ac0effd..40ce4d74185 100644
--- a/smoke-tests/scenarios/basic-test.ts
+++ b/smoke-tests/scenarios/basic-test.ts
@@ -233,6 +233,78 @@ function basicTest(scenarios: Scenarios, appName: string) {
                 });
               });
             `,
+            'create-context-test.gjs': `
+              import { module, test } from 'qunit';
+              import { render, rerender } from '@ember/test-helpers';
+              import { setupRenderingTest } from 'ember-qunit';
+              import { createContext } from '@ember/helper';
+              import { tracked } from '@glimmer/tracking';
+
+              module('Integration | createContext (RFC #1200)', function (hooks) {
+                setupRenderingTest(hooks);
+
+                test('provide a value via @value and consume it', async function (assert) {
+                  class Theme {
+                    color = 'dark';
+                  }
+                  const theme = createContext();
+                  const value = new Theme();
+
+                  await render(
+                    <template>
+                      <theme.Provide @value={{value}}>
+                        {{#let theme.value as |t|}}
+                          <div data-test="color">{{t.color}}</div>
+                        {{/let}}
+                      </theme.Provide>
+                    </template>
+                  );
+
+                  assert.dom('[data-test="color"]').hasText('dark');
+                });
+
+                test('consumer reads the nearest provider', async function (assert) {
+                  const ctx = createContext();
+
+                  await render(
+                    <template>
+                      <ctx.Provide @value="outer">
+                        {{#let ctx.value as |v|}}<div data-test="outer">{{v}}</div>{{/let}}
+                        <ctx.Provide @value="inner">
+                          {{#let ctx.value as |v|}}<div data-test="inner">{{v}}</div>{{/let}}
+                        </ctx.Provide>
+                      </ctx.Provide>
+                    </template>
+                  );
+
+                  assert.dom('[data-test="outer"]').hasText('outer');
+                  assert.dom('[data-test="inner"]').hasText('inner');
+                });
+
+                test('consumer re-renders when @value changes', async function (assert) {
+                  class State {
+                    @tracked count = 1;
+                  }
+                  const state = new State();
+                  const ctx = createContext();
+
+                  await render(
+                    <template>
+                      <ctx.Provide @value={{state.count}}>
+                        {{#let ctx.value as |v|}}<div data-test="count">{{v}}</div>{{/let}}
+                      </ctx.Provide>
+                    </template>
+                  );
+
+                  assert.dom('[data-test="count"]').hasText('1');
+
+                  state.count = 2;
+                  await rerender();
+
+                  assert.dom('[data-test="count"]').hasText('2');
+                });
+              });
+            `,
             'interactive-example-test.js': `
               import { module, test } from 'qunit';
               import { setupRenderingTest } from 'ember-qunit';
diff --git a/tests/docs/expected.cjs b/tests/docs/expected.cjs
index db1994ff30a..bfbcd844102 100644
--- a/tests/docs/expected.cjs
+++ b/tests/docs/expected.cjs
@@ -130,6 +130,7 @@ module.exports = {
     'controllerName',
     'create',
     'createCache',
+    'createContext',
     'currentRoute',
     'currentRouteName',
     'currentURL',
diff --git a/type-tests/@ember/helper-tests.ts b/type-tests/@ember/helper-tests.ts
index 5a75c993384..8cff51c3aac 100644
--- a/type-tests/@ember/helper-tests.ts
+++ b/type-tests/@ember/helper-tests.ts
@@ -9,6 +9,8 @@ import {
   type GetHelper,
   hash,
   type HashHelper,
+  createContext,
+  type Context,
   uniqueId,
   type UniqueIdHelper,
 } from '@ember/helper';
@@ -20,3 +22,28 @@ expectTypeOf(fn).toEqualTypeOf<FnHelper>();
 expectTypeOf(get).toEqualTypeOf<GetHelper>();
 expectTypeOf(hash).toEqualTypeOf<HashHelper>();
 expectTypeOf(uniqueId).toEqualTypeOf<UniqueIdHelper>();
+
+// createContext takes a type parameter, not a value -- the value is supplied
+// at render time via `<Provide @value>`.
+class Theme {
+  color = 'dark';
+}
+const theme = createContext<Theme>();
+expectTypeOf(theme).toEqualTypeOf<Context<Theme>>();
+// `value` is a getter, not a function
+expectTypeOf(theme.value).toEqualTypeOf<Theme>();
+
+// @ts-expect-error createContext does not accept a class (or any value) argument
+createContext(Theme);
+
+// `consume()` with no argument reads ambiently, like `value`
+expectTypeOf(theme.consume()).toEqualTypeOf<Theme>();
+
+// `consume(component)` resolves from a component instance's render-tree
+// position (validity of the instance is checked at runtime)
+declare const componentInstance: object;
+expectTypeOf(theme.consume(componentInstance)).toEqualTypeOf<Theme>();
+
+// consume takes an object, not a primitive
+// @ts-expect-error
+theme.consume('not-a-component');