diff --git a/packages/@ember/-internals/glimmer/lib/create-context.ts b/packages/@ember/-internals/glimmer/lib/create-context.ts
index 545fe615dcb..1ef1487e823 100644
--- a/packages/@ember/-internals/glimmer/lib/create-context.ts
+++ b/packages/@ember/-internals/glimmer/lib/create-context.ts
@@ -2,7 +2,11 @@
  * @module @ember/helper
  */
 import { precompileTemplate } from '@ember/template-compilation';
-import { lookupRenderContext, provideRenderContext } from '@glimmer/runtime/lib/render-scope';
+import {
+  lookupRenderContext,
+  lookupRenderContextFor,
+  provideRenderContext,
+} from '@glimmer/runtime/lib/render-scope';
 import { valueForRef } from '@glimmer/reference/lib/reference';
 import InternalComponent, {
   type OpaqueInternalComponentConstructor,
@@ -11,12 +15,14 @@ import InternalComponent, {
 
 /**
  * The shape returned by `createContext`. Use `Provide` in templates to bind a
- * value into the render tree and read `value` to get the nearest enclosing
- * provided value.
+ * 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;
 }
 
 /**
@@ -69,11 +75,44 @@ export interface Context<T> {
  * 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`) and `value` (a getter that reads the nearest provided value).
+ *   `@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> {
@@ -104,19 +143,45 @@ export function createContext<T>(): Context<T> {
     }
   }
 
+  // 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 {
-      let read = lookupRenderContext(key);
+      return resolveAmbient();
+    },
+
+    consume(consumer?: object): T {
+      if (consumer === undefined) {
+        return resolveAmbient();
+      }
+
+      let read = lookupRenderContextFor(consumer, 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.'
+          '`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 in the render tree. Wrap consumers in `<Context.Provide @value={{...}}>...</Context.Provide>`, or provide a default at the application root.'
+          '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;
diff --git a/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts b/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts
index 39d59861e8a..17b3ae4f592 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts
+++ b/packages/@ember/-internals/glimmer/tests/integration/create-context-test.ts
@@ -13,6 +13,7 @@ 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';
@@ -892,3 +893,274 @@ moduleFor(
     }
   }
 );
+
+/**
+ * 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 92152f2a831..9bd4b1b1de3 100644
--- a/packages/@ember/helper/index.ts
+++ b/packages/@ember/helper/index.ts
@@ -727,6 +727,10 @@ export interface NotHelper extends Opaque<'helper:not'> {}
  * - `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';
@@ -750,10 +754,37 @@ export interface NotHelper extends Opaque<'helper:not'> {}
  * 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 }`
+ * @returns {Object} `{ Provide, value, consume }`
  * @public
  */
 export { createContext } from '@ember/-internals/glimmer/lib/create-context';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
index 961ec280cd8..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
@@ -665,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;
diff --git a/packages/@glimmer/runtime/lib/render-scope.ts b/packages/@glimmer/runtime/lib/render-scope.ts
index bf6eab315f3..1e56cda603b 100644
--- a/packages/@glimmer/runtime/lib/render-scope.ts
+++ b/packages/@glimmer/runtime/lib/render-scope.ts
@@ -67,14 +67,25 @@ export class RenderScopeTracker {
     if (current === null) {
       return undefined;
     }
-    for (let node: Nullable<RenderScopeNode> = current; node !== null; node = node.parent) {
-      let read = node.contexts?.get(key);
-      if (read !== undefined) {
-        return read;
-      }
+    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;
   }
+  return null;
 }
 
 // The renderer points this at the active tracker for the duration of a render,
@@ -103,3 +114,42 @@ export function provideRenderContext(key: object, read: ContextRead): void {
 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/type-tests/@ember/helper-tests.ts b/type-tests/@ember/helper-tests.ts
index 014d54a3855..8cff51c3aac 100644
--- a/type-tests/@ember/helper-tests.ts
+++ b/type-tests/@ember/helper-tests.ts
@@ -35,3 +35,15 @@ 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');