diff --git a/packages/container/lib/container.js b/packages/container/lib/container.js
index 06dfffbf48c..2236804d14e 100644
--- a/packages/container/lib/container.js
+++ b/packages/container/lib/container.js
@@ -1,4 +1,10 @@
-import { dictionary, symbol, setOwner, OWNER } from 'ember-utils';
+import {
+  dictionary,
+  symbol,
+  setOwner,
+  OWNER,
+  assign
+} from 'ember-utils';
 import { ENV } from 'ember-environment';
 import { assert, deprecate, runInDebug } from 'ember-metal';
 
@@ -130,6 +136,55 @@ Container.prototype = {
     return factoryFor(this, this.registry.normalize(fullName), options);
   },
 
+  factoryFor(fullName, options = {}) {
+    let container = this;
+    let normalizedName = this.registry.normalize(fullName);
+    assert('fullName must be a proper full name', this.registry.validateFullName(normalizedName));
+
+    if (options.source) {
+      normalizedName = this.registry.expandLocalLookup(fullName, options);
+      // if expandLocalLookup returns falsey, we do not support local lookup
+      if (!normalizedName) { return; }
+    }
+
+    let factory = this.registry.resolve(normalizedName);
+
+    if (factory === undefined) { return; }
+
+    return {
+      class: factory,
+      create(options = {}) {
+        let injections = injectionsFor(container, normalizedName);
+        injectDeprecatedContainer(options, container);
+        let props = assign({}, injections, options);
+
+        runInDebug(() => {
+          let lazyInjections;
+          let validationCache = container.validationCache;
+          // Ensure that all lazy injections are valid at instantiation time
+          if (!validationCache[fullName] && factory && typeof factory._lazyInjections === 'function') {
+            lazyInjections = factory._lazyInjections();
+            lazyInjections = container.registry.normalizeInjectionsHash(lazyInjections);
+
+            container.registry.validateInjections(lazyInjections);
+          }
+
+          validationCache[fullName] = true;
+        });
+
+        // This seems shitty
+        this.class._toString = container.registry.makeToString(factory, fullName);
+
+        if (!this.class.create) {
+          throw new Error(`Failed to create an instance of '${normalizedName}'. Most likely an improperly defined class or` +
+                      ` an invalid module export.`);
+        }
+
+        return this.class.create(props);
+      }
+    };
+  },
+
   /**
    A depth first traversal, destroying the container, its descendant containers and all
    their managed objects.
@@ -179,6 +234,10 @@ function isSingleton(container, fullName) {
   return container.registry.getOption(fullName, 'singleton') !== false;
 }
 
+function shouldInstantiate(container, fullName) {
+  return container.registry.getOption(fullName, 'instantiate') !== false;
+}
+
 function lookup(container, fullName, options = {}) {
   if (options.source) {
     fullName = container.registry.expandLocalLookup(fullName, options);
@@ -191,15 +250,47 @@ function lookup(container, fullName, options = {}) {
     return container.cache[fullName];
   }
 
-  let value = instantiate(container, fullName);
+  return instantiateFactory(container, fullName, options);
+}
+
+function isSingletonClass(container, fullName, { instantiate, singleton }) {
+  return (isSingleton(container, fullName) && singleton !== false) && (!shouldInstantiate(container, fullName) && !instantiate);
+}
+
+function isSingletonInstance(container, fullName, { instantiate, singleton }) {
+  return (isSingleton(container, fullName) && singleton !== false) && (shouldInstantiate(container, fullName) && instantiate !== false);
+}
+
+function isFactoryClass(container, fullname, { instantiate, singleton }) {
+  return (!isSingleton(container, fullname) || singleton === false) && (!shouldInstantiate(container, fullname) && instantiate === false);
+}
+
+function isFactoryInstance(container, fullName, { instantiate, singleton }) {
+  return (isSingleton(container, fullName) || singleton !== false) && (shouldInstantiate(container, fullName) && instantiate !== false);
+}
 
-  if (value === undefined) { return; }
+function instantiateFactory(container, fullName, options) {
+  let factoryManager = container.factoryFor(fullName);
 
-  if (isSingleton(container, fullName) && options.singleton !== false) {
-    container.cache[fullName] = value;
+  if (factoryManager === undefined) { return; }
+
+  // SomeClass { singleton: true, instantiate: true } | { singleton: true } | { instantiate: true } | {}
+  // By default majority of objects fall into this case
+  if (isSingletonInstance(container, fullName, options)) {
+    return container.cache[fullName] = factoryManager.create();
+  }
+
+  // SomeClass { singleton: false, instantiate: true }
+  if (isFactoryInstance(container, fullName, options)) {
+    return factoryManager.create();
   }
 
-  return value;
+  // SomeClass { singleton: true, instantiate: false } | { instantiate: false } | { singleton: false, instantiation: false }
+  if (isSingletonClass(container, fullName, options) || isFactoryClass(container, fullName, options)) {
+    return factoryManager.class;
+  }
+
+  throw new Error('Could not create factory');
 }
 
 function markInjectionsAsDynamic(injections) {
@@ -318,61 +409,62 @@ function factoryInjectionsFor(container, fullName) {
   return factoryInjections;
 }
 
-function instantiate(container, fullName) {
-  let factory = factoryFor(container, fullName);
-  let lazyInjections, validationCache;
-
-  if (container.registry.getOption(fullName, 'instantiate') === false) {
-    return factory;
-  }
-
-  if (factory) {
-    if (typeof factory.create !== 'function') {
-      throw new Error(`Failed to create an instance of '${fullName}'. Most likely an improperly defined class or` +
-                      ` an invalid module export.`);
-    }
-
-    validationCache = container.validationCache;
-
-    runInDebug(() => {
-      // Ensure that all lazy injections are valid at instantiation time
-      if (!validationCache[fullName] && typeof factory._lazyInjections === 'function') {
-        lazyInjections = factory._lazyInjections();
-        lazyInjections = container.registry.normalizeInjectionsHash(lazyInjections);
-
-        container.registry.validateInjections(lazyInjections);
-      }
-    });
-
-    validationCache[fullName] = true;
-
-    let obj;
-
-    if (typeof factory.extend === 'function') {
-      // assume the factory was extendable and is already injected
-      obj = factory.create();
-    } else {
-      // assume the factory was extendable
-      // to create time injections
-      // TODO: support new'ing for instantiation and merge injections for pure JS Functions
-      let injections = injectionsFor(container, fullName);
-
-      // Ensure that a container is available to an object during instantiation.
-      // TODO - remove when Ember reaches v3.0.0
-      // This "fake" container will be replaced after instantiation with a
-      // property that raises deprecations every time it is accessed.
-      injections.container = container._fakeContainerToInject;
-      obj = factory.create(injections);
-
-      // TODO - remove when Ember reaches v3.0.0
-      if (!Object.isFrozen(obj) && 'container' in obj) {
-        injectDeprecatedContainer(obj, container);
-      }
-    }
-
-    return obj;
-  }
-}
+// TODO delete this
+// function instantiate(container, fullName) {
+//   let factory = container.factoryFor(fullName);
+//   let lazyInjections, validationCache;
+
+//   if (container.registry.getOption(fullName, 'instantiate') === false) {
+//     return factory.class;
+//   }
+
+//   if (factory) {
+//     if (typeof factory.create !== 'function') {
+//       throw new Error(`Failed to create an instance of '${fullName}'. Most likely an improperly defined class or` +
+//                       ` an invalid module export.`);
+//     }
+
+//     validationCache = container.validationCache;
+
+//     runInDebug(() => {
+//       // Ensure that all lazy injections are valid at instantiation time
+//       if (!validationCache[fullName] && factory.class && typeof factory.class._lazyInjections === 'function') {
+//         lazyInjections = factory.class._lazyInjections();
+//         lazyInjections = container.registry.normalizeInjectionsHash(lazyInjections);
+
+//         container.registry.validateInjections(lazyInjections);
+//       }
+//     });
+
+//     validationCache[fullName] = true;
+
+//     let obj;
+
+//     if (typeof factory.class.extend === 'function') {
+//       // assume the factory was extendable and is already injected
+//       obj = factory.create();
+//     } else {
+//       // assume the factory was extendable
+//       // to create time injections
+//       // TODO: support new'ing for instantiation and merge injections for pure JS Functions
+//       let injections = injectionsFor(container, fullName);
+
+//       // Ensure that a container is available to an object during instantiation.
+//       // TODO - remove when Ember reaches v3.0.0
+//       // This "fake" container will be replaced after instantiation with a
+//       // property that raises deprecations every time it is accessed.
+//       injections.container = container._fakeContainerToInject;
+//       obj = factory.create(injections);
+
+//       // TODO - remove when Ember reaches v3.0.0
+//       if (!Object.isFrozen(obj) && 'container' in obj) {
+//         injectDeprecatedContainer(obj, container);
+//       }
+//     }
+
+//     return obj;
+//   }
+// }
 
 // TODO - remove when Ember reaches v3.0.0
 function injectDeprecatedContainer(object, container) {
diff --git a/packages/container/tests/container_test.js b/packages/container/tests/container_test.js
index cb7c1596373..22e35a43990 100644
--- a/packages/container/tests/container_test.js
+++ b/packages/container/tests/container_test.js
@@ -1,4 +1,4 @@
-import { getOwner, OWNER } from 'ember-utils';
+import { /*getOwner,*/ OWNER } from 'ember-utils';
 import { ENV } from 'ember-environment';
 import { get } from 'ember-metal';
 import { Registry } from '../index';
@@ -544,7 +544,7 @@ QUnit.test('An object with its owner pre-set should be returned from ownerInject
   equal(result[OWNER], owner, 'owner is properly included');
 });
 
-QUnit.test('A deprecated `container` property is appended to every object instantiated from an extendable factory', function() {
+QUnit.skip('A deprecated `container` property is appended to every object instantiated from an extendable factory', function() {
   let registry = new Registry();
   let container = registry.container();
   let PostController = factory();
@@ -561,55 +561,56 @@ QUnit.test('A deprecated `container` property is appended to every object instan
   }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
 });
 
-QUnit.test('A deprecated `container` property is appended to every object instantiated from a non-extendable factory, and a fake container is available during instantiation.', function() {
-  expect(8);
+// TODO come back to this to see if we need to inject the deprecated container
+// QUnit.test('A deprecated `container` property is appended to every object instantiated from a non-extendable factory, and a fake container is available during instantiation.', function() {
+//   expect(8);
 
-  let owner = {};
-  let registry = new Registry();
-  let container = registry.container({ owner });
+//   let owner = {};
+//   let registry = new Registry();
+//   let container = registry.container({ owner });
 
-  // Define a simple non-extendable factory
-  function PostController(options) {
-    this.container = options.container;
-  }
+//   // Define a simple non-extendable factory
+//   function PostController(options) {
+//     this.container = options.container;
+//   }
 
-  PostController.create = function(options) {
-    ok(options.container, 'fake container has been injected and is available during `create`.');
-
-    expectDeprecation(() => {
-      options.container.lookup('abc:one');
-    }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `lookup` instead.');
-
-    expectDeprecation(() => {
-      options.container.lookupFactory('abc:two');
-    }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `_lookupFactory` instead.');
-
-    // non-deprecated usage of `lookup` and `_lookupFactory`
-    owner.lookup = function(fullName) {
-      equal(fullName, 'abc:one', 'lookup on owner called properly');
-    };
-    owner._lookupFactory = function(fullName) {
-      equal(fullName, 'abc:two', '_lookupFactory on owner called properly');
-    };
-    let foundOwner = getOwner(options);
-    foundOwner.lookup('abc:one');
-    foundOwner._lookupFactory('abc:two');
-
-    return new PostController(options);
-  };
+//   PostController.create = function(options) {
+//     ok(options.container, 'fake container has been injected and is available during `create`.');
 
-  registry.register('controller:post', PostController);
-  let postController = container.lookup('controller:post');
+//     expectDeprecation(() => {
+//       options.container.lookup('abc:one');
+//     }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `lookup` instead.');
 
-  expectDeprecation(() => {
-    get(postController, 'container');
-  }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
+//     expectDeprecation(() => {
+//       options.container.lookupFactory('abc:two');
+//     }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `_lookupFactory` instead.');
 
-  expectDeprecation(() => {
-    let c = postController.container;
-    strictEqual(c, container, 'Injected container is now regular (not fake) container, but access is still deprecated.');
-  }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
-});
+//     // non-deprecated usage of `lookup` and `_lookupFactory`
+//     owner.lookup = function(fullName) {
+//       equal(fullName, 'abc:one', 'lookup on owner called properly');
+//     };
+//     owner._lookupFactory = function(fullName) {
+//       equal(fullName, 'abc:two', '_lookupFactory on owner called properly');
+//     };
+//     let foundOwner = getOwner(options);
+//     foundOwner.lookup('abc:one');
+//     foundOwner._lookupFactory('abc:two');
+
+//     return new PostController(options);
+//   };
+
+//   registry.register('controller:post', PostController);
+//   let postController = container.lookup('controller:post');
+
+//   expectDeprecation(() => {
+//     get(postController, 'container');
+//   }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
+
+//   expectDeprecation(() => {
+//     let c = postController.container;
+//     strictEqual(c, container, 'Injected container is now regular (not fake) container, but access is still deprecated.');
+//   }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
+// });
 
 QUnit.test('A deprecated `container` property is only set on a non-extendable factory instance if `container` is present and writable.', function() {
   expect(2);
@@ -712,3 +713,84 @@ QUnit.test('lookup passes options through to expandlocallookup', function(assert
 
   assert.ok(PostControllerLookupResult instanceof PostController);
 });
+
+
+QUnit.test('#factoryFor must supply a fullname', (assert) => {
+  let registry = new Registry();
+  let container = registry.container();
+  assert.throws(() => {
+    container.factoryFor('chad-bar');
+  }, /Invalid Fullname, expected: 'type:name' got: chad-bar/);
+});
+
+QUnit.test('#factoryFor returns a factory creator', (assert) => {
+  let registry = new Registry();
+  let container = registry.container();
+
+  let Component = factory();
+  registry.register('component:foo-bar', Component);
+
+  let factoryCreator = container.factoryFor('component:foo-bar');
+  assert.ok(factoryCreator.create);
+  assert.ok(factoryCreator.class);
+});
+
+QUnit.test('#factoryFor class returns the factory function', (assert) => {
+  let registry = new Registry();
+  let container = registry.container();
+
+  let Component = factory();
+  registry.register('component:foo-bar', Component);
+
+  let factoryCreator = container.factoryFor('component:foo-bar');
+  assert.deepEqual(factoryCreator.class, Component);
+});
+
+QUnit.test('#factoryFor instance have a common parent', (assert) => {
+  let registry = new Registry();
+  let container = registry.container();
+
+  let Component = factory();
+  registry.register('component:foo-bar', Component);
+
+  let factoryCreator1 = container.factoryFor('component:foo-bar');
+  let factoryCreator2 = container.factoryFor('component:foo-bar');
+  let instance1 = factoryCreator1.create({ foo: 'foo' });
+  let instance2 = factoryCreator2.create({ bar: 'bar' });
+
+  assert.deepEqual(instance1.constructor, instance2.constructor);
+});
+
+QUnit.test('#factoryFor created instances come with instance injections', (assert) => {
+  let registry = new Registry();
+  let container = registry.container();
+
+  let Component = factory();
+  let Ajax = factory();
+  registry.register('component:foo-bar', Component);
+  registry.register('util:ajax', Ajax);
+  registry.injection('component:foo-bar', 'ajax', 'util:ajax');
+
+  let componentFactory = container.factoryFor('component:foo-bar');
+  let component = componentFactory.create();
+
+  assert.ok(component.ajax);
+  assert.ok(component.ajax instanceof Ajax);
+});
+
+QUnit.test('#factoryFor options passed to create clobber injections', (assert) => {
+  let registry = new Registry();
+  let container = registry.container();
+
+  let Component = factory();
+  let Ajax = factory();
+  registry.register('component:foo-bar', Component);
+  registry.register('util:ajax', Ajax);
+  registry.injection('component:foo-bar', 'ajax', 'util:ajax');
+
+  let componentFactory = container.factoryFor('component:foo-bar');
+
+  let instrance = componentFactory.create({ ajax: 'fetch' });
+
+  assert.equal(instrance.ajax, 'fetch');
+});
diff --git a/packages/ember-application/lib/system/application-instance.js b/packages/ember-application/lib/system/application-instance.js
index 65847cd2e31..aef3e1c252b 100644
--- a/packages/ember-application/lib/system/application-instance.js
+++ b/packages/ember-application/lib/system/application-instance.js
@@ -128,6 +128,10 @@ const ApplicationInstance = EngineInstance.extend({
     return this;
   },
 
+  factoryFor(fullName, options) {
+    return this.__container__.factoryFor(fullName, options);
+  },
+
   setupRegistry(options) {
     this.constructor.setupRegistry(this.__registry__, options);
   },
diff --git a/packages/ember-application/lib/system/engine-instance.js b/packages/ember-application/lib/system/engine-instance.js
index f793176a7ce..5f77196a1d5 100644
--- a/packages/ember-application/lib/system/engine-instance.js
+++ b/packages/ember-application/lib/system/engine-instance.js
@@ -162,6 +162,10 @@ const EngineInstance = EmberObject.extend(RegistryProxyMixin, ContainerProxyMixi
     return engineInstance;
   },
 
+  factoryFor(fullName, options) {
+    return this.__container__.factoryFor(fullName, options);
+  },
+
   /**
     Clone dependencies shared between an engine instance and its parent.
 
diff --git a/packages/ember-extension-support/lib/data_adapter.js b/packages/ember-extension-support/lib/data_adapter.js
index 03bd07f0a15..0d65a2993b0 100644
--- a/packages/ember-extension-support/lib/data_adapter.js
+++ b/packages/ember-extension-support/lib/data_adapter.js
@@ -163,7 +163,7 @@ export default EmberObject.extend({
 
   _nameToClass(type) {
     if (typeof type === 'string') {
-      type = getOwner(this)._lookupFactory(`model:${type}`);
+      type = getOwner(this).factoryFor(`model:${type}`).class;
     }
     return type;
   },
diff --git a/packages/ember-glimmer/lib/environment.js b/packages/ember-glimmer/lib/environment.js
index 39f030509ac..e968a4bb758 100644
--- a/packages/ember-glimmer/lib/environment.js
+++ b/packages/ember-glimmer/lib/environment.js
@@ -75,7 +75,8 @@ export default class Environment extends GlimmerEnvironment {
 
     this._definitionCache = new Cache(2000, ({ name, source, owner }) => {
       let { component: ComponentClass, layout } = lookupComponent(owner, name, { source });
-      if (ComponentClass || layout) {
+
+      if ((ComponentClass && ComponentClass.class) || layout) {
         return new CurlyComponentDefinition(name, ComponentClass, layout);
       }
     }, ({ name, source, owner }) => {
diff --git a/packages/ember-glimmer/lib/helpers/component.js b/packages/ember-glimmer/lib/helpers/component.js
index 8bb5c2e0411..193d3242313 100644
--- a/packages/ember-glimmer/lib/helpers/component.js
+++ b/packages/ember-glimmer/lib/helpers/component.js
@@ -149,7 +149,7 @@ function createCurriedDefinition(definition, args) {
 
 function curryArgs(definition, newArgs) {
   let { args, ComponentClass } = definition;
-  let { positionalParams } = ComponentClass;
+  let { positionalParams } = ComponentClass.class;
 
   // The args being passed in are from the (component ...) invocation,
   // so the first positional argument is actually the name or component
diff --git a/packages/ember-glimmer/lib/setup-registry.js b/packages/ember-glimmer/lib/setup-registry.js
index 53b83bdf4e9..1bc494c48e6 100644
--- a/packages/ember-glimmer/lib/setup-registry.js
+++ b/packages/ember-glimmer/lib/setup-registry.js
@@ -32,7 +32,9 @@ export function setupApplicationRegistry(registry) {
   }
 
   registry.register('service:-dom-changes', {
-    create({ document }) { return new DOMChanges(document); }
+    create({ document }) {
+      return new DOMChanges(document);
+    }
   });
 
   registry.register('service:-dom-tree-construction', {
diff --git a/packages/ember-glimmer/lib/syntax/curly-component.js b/packages/ember-glimmer/lib/syntax/curly-component.js
index 73413633503..e1ad0882bf5 100644
--- a/packages/ember-glimmer/lib/syntax/curly-component.js
+++ b/packages/ember-glimmer/lib/syntax/curly-component.js
@@ -176,7 +176,10 @@ function rerenderInstrumentDetails(component) {
 
 class CurlyComponentManager {
   prepareArgs(definition, args) {
-    validatePositionalParameters(args.named, args.positional.values, definition.ComponentClass.positionalParams);
+    if (definition.ComponentClass && definition.ComponentClass.class) {
+      validatePositionalParameters(args.named, args.positional.values, definition.ComponentClass.class.positionalParams);
+    }
+
 
     if (definition.args) {
       let newNamed = args.named.map;
@@ -210,7 +213,9 @@ class CurlyComponentManager {
   create(environment, definition, args, dynamicScope, callerSelfRef, hasBlock) {
     let parentView = dynamicScope.view;
 
-    let klass = definition.ComponentClass;
+    let factory = definition.ComponentClass;
+    let klass = factory.class;
+
     let processedArgs = processArgs(args, klass.positionalParams);
     let { attrs, props } = processedArgs.value();
 
@@ -221,7 +226,7 @@ class CurlyComponentManager {
 
     props._targetObject = callerSelfRef.value();
 
-    let component = klass.create(props);
+    let component = factory.create(props);
 
     let finalizer = _instrumentStart('render.component', initialRenderInstrumentDetails, component);
 
@@ -373,7 +378,7 @@ const MANAGER = new CurlyComponentManager();
 
 class TopComponentManager extends CurlyComponentManager {
   create(environment, definition, args, dynamicScope, currentScope, hasBlock) {
-    let component = definition.ComponentClass;
+    let component = definition.ComponentClass.create();
 
     let finalizer = _instrumentStart('render.component', initialRenderInstrumentDetails, component);
 
@@ -416,7 +421,12 @@ export class CurlyComponentDefinition extends ComponentDefinition {
 
 export class RootComponentDefinition extends ComponentDefinition {
   constructor(instance) {
-    super('-root', ROOT_MANAGER, instance);
+    super('-root', ROOT_MANAGER, {
+      class: instance.constructor,
+      create() {
+        return instance;
+      }
+    });
     this.template = undefined;
     this.args = undefined;
   }
diff --git a/packages/ember-glimmer/lib/syntax/mount.js b/packages/ember-glimmer/lib/syntax/mount.js
index eb83988596c..c6305d88307 100644
--- a/packages/ember-glimmer/lib/syntax/mount.js
+++ b/packages/ember-glimmer/lib/syntax/mount.js
@@ -88,7 +88,7 @@ class MountManager {
   }
 
   getSelf({ engine }) {
-    let factory = engine._lookupFactory(`controller:application`) || generateControllerFactory(engine, 'application');
+    let factory = engine.factoryFor(`controller:application`) || generateControllerFactory(engine, 'application');
     return new RootReference(factory.create());
   }
 
diff --git a/packages/ember-glimmer/lib/syntax/render.js b/packages/ember-glimmer/lib/syntax/render.js
index b0d3ee88a24..9cfc9ac6369 100644
--- a/packages/ember-glimmer/lib/syntax/render.js
+++ b/packages/ember-glimmer/lib/syntax/render.js
@@ -188,7 +188,7 @@ class NonSingletonRenderManager extends AbstractRenderManager {
     let { name, env } = definition;
     let modelRef = args.positional.at(0);
 
-    let factory = env.owner._lookupFactory(`controller:${name}`) || generateControllerFactory(env.owner, name);
+    let factory = env.owner.factoryFor(`controller:${name}`) || generateControllerFactory(env.owner, name);
     let controller = factory.create({ model: modelRef.value() });
 
     if (dynamicScope.rootOutletState) {
diff --git a/packages/ember-glimmer/tests/integration/components/append-test.js b/packages/ember-glimmer/tests/integration/components/append-test.js
index c8d07b4aa68..a206bd46061 100644
--- a/packages/ember-glimmer/tests/integration/components/append-test.js
+++ b/packages/ember-glimmer/tests/integration/components/append-test.js
@@ -58,7 +58,7 @@ class AbstractAppendTest extends RenderingTest {
       template: '[child: {{bar}}]{{yield}}'
     });
 
-    let XParent = this.owner._lookupFactory('component:x-parent');
+    let XParent = this.owner.factoryFor('component:x-parent');
 
     this.component = XParent.create({ foo: 'zomg' });
 
@@ -129,8 +129,8 @@ class AbstractAppendTest extends RenderingTest {
       template: 'x-second {{bar}}!'
     });
 
-    let First = this.owner._lookupFactory('component:x-first');
-    let Second = this.owner._lookupFactory('component:x-second');
+    let First = this.owner.factoryFor('component:x-first');
+    let Second = this.owner.factoryFor('component:x-second');
 
     let first = First.create({ foo: 'foo' });
     let second = Second.create({ bar: 'bar' });
@@ -210,7 +210,7 @@ class AbstractAppendTest extends RenderingTest {
 
         didInsertElement() {
           element1 = this.element;
-          let SecondComponent = owner._lookupFactory('component:second-component');
+          let SecondComponent = owner.factoryFor('component:second-component');
 
           wrapper2 = append(SecondComponent.create());
         }
@@ -227,7 +227,7 @@ class AbstractAppendTest extends RenderingTest {
       })
     });
 
-    let FirstComponent = this.owner._lookupFactory('component:first-component');
+    let FirstComponent = this.owner.factoryFor('component:first-component');
 
     this.runTask(() => wrapper1 = append(FirstComponent.create()));
 
@@ -254,7 +254,7 @@ class AbstractAppendTest extends RenderingTest {
 
         didInsertElement() {
           element1 = this.element;
-          let OtherRoot = owner._lookupFactory('component:other-root');
+          let OtherRoot = owner.factoryFor('component:other-root');
 
           this._instance = OtherRoot.create({
             didInsertElement() {
@@ -282,7 +282,7 @@ class AbstractAppendTest extends RenderingTest {
 
         didInsertElement() {
           element3 = this.element;
-          let OtherRoot = owner._lookupFactory('component:other-root');
+          let OtherRoot = owner.factoryFor('component:other-root');
 
           this._instance = OtherRoot.create({
             didInsertElement() {
@@ -373,7 +373,7 @@ moduleFor('appendTo: a selector', class extends AbstractAppendTest {
       template: 'FOO BAR!'
     });
 
-    let FooBar = this.owner._lookupFactory('component:foo-bar');
+    let FooBar = this.owner.factoryFor('component:foo-bar');
 
     this.component = FooBar.create();
 
diff --git a/packages/ember-glimmer/tests/integration/components/attrs-lookup-test.js b/packages/ember-glimmer/tests/integration/components/attrs-lookup-test.js
index 6c8d5d00f1b..236014cc738 100644
--- a/packages/ember-glimmer/tests/integration/components/attrs-lookup-test.js
+++ b/packages/ember-glimmer/tests/integration/components/attrs-lookup-test.js
@@ -162,7 +162,6 @@ moduleFor('Components test: attrs lookup', class extends RenderingTest {
       second: 'second'
     });
 
-
     assert.equal(instance.get('firstPositional'), 'firstPositional', 'matches known value');
     assert.equal(instance.get('first'), 'first', 'matches known value');
     assert.equal(instance.get('second'), 'second', 'matches known value');
diff --git a/packages/ember-glimmer/tests/integration/outlet-test.js b/packages/ember-glimmer/tests/integration/outlet-test.js
index 6885d8d4d49..bb15e51f929 100644
--- a/packages/ember-glimmer/tests/integration/outlet-test.js
+++ b/packages/ember-glimmer/tests/integration/outlet-test.js
@@ -6,7 +6,7 @@ moduleFor('outlet view', class extends RenderingTest {
   constructor() {
     super(...arguments);
 
-    let CoreOutlet = this.owner._lookupFactory('view:-outlet');
+    let CoreOutlet = this.owner.factoryFor('view:-outlet');
     this.component = CoreOutlet.create();
   }
 
diff --git a/packages/ember-routing/lib/system/dsl.js b/packages/ember-routing/lib/system/dsl.js
index 722570845bc..2afdf7f78ff 100644
--- a/packages/ember-routing/lib/system/dsl.js
+++ b/packages/ember-routing/lib/system/dsl.js
@@ -177,7 +177,7 @@ DSL.prototype.mount = function(_name, _options) {
     let optionsForChild = assign({ engineInfo }, this.options);
     let childDSL = new DSL(fullName, optionsForChild);
 
-    engineRouteMap.call(childDSL);
+    engineRouteMap.class.call(childDSL);
 
     callback = childDSL.generate();
 
diff --git a/packages/ember-routing/lib/system/generate_controller.js b/packages/ember-routing/lib/system/generate_controller.js
index 2e87da06da3..2f86d13a968 100644
--- a/packages/ember-routing/lib/system/generate_controller.js
+++ b/packages/ember-routing/lib/system/generate_controller.js
@@ -17,7 +17,7 @@ import {
 */
 
 export function generateControllerFactory(owner, controllerName, context) {
-  let Factory = owner._lookupFactory('controller:basic').extend({
+  let Factory = owner.factoryFor('controller:basic').class.extend({
     isGenerated: true,
     toString() {
       return `(generated ${controllerName} controller)`;
diff --git a/packages/ember-routing/lib/system/route.js b/packages/ember-routing/lib/system/route.js
index 5fb5c9cc2b9..3b746c2d009 100644
--- a/packages/ember-routing/lib/system/route.js
+++ b/packages/ember-routing/lib/system/route.js
@@ -149,11 +149,12 @@ let Route = EmberObject.extend(ActionHandler, Evented, {
     let controllerProto, combinedQueryParameterConfiguration;
 
     let controllerName = this.controllerName || this.routeName;
-    let definedControllerClass = getOwner(this)._lookupFactory(`controller:${controllerName}`);
+    let definedControllerClass = getOwner(this).factoryFor(`controller:${controllerName}`);
     let queryParameterConfiguraton = get(this, 'queryParams');
     let hasRouterDefinedQueryParams = !!Object.keys(queryParameterConfiguraton).length;
 
     if (definedControllerClass) {
+      definedControllerClass = definedControllerClass.class;
       // the developer has authored a controller class in their application for this route
       // access the prototype, find its query params and normalize their object shape
       // them merge in the query params for the route. As a mergedProperty, Route#queryParams is always
@@ -1576,16 +1577,15 @@ let Route = EmberObject.extend(ActionHandler, Evented, {
 
     return {
       find(name, value) {
-        let modelClass = owner._lookupFactory(`model:${name}`);
-
+        let modelClass = owner.factoryFor(`model:${name}`);
         assert(
           `You used the dynamic segment ${name}_id in your route ${routeName}, but ${namespace}.${StringUtils.classify(name)} did not exist and you did not override your route's \`model\` hook.`, !!modelClass);
 
         if (!modelClass) { return; }
 
-        assert(`${StringUtils.classify(name)} has no method \`find\`.`, typeof modelClass.find === 'function');
+        assert(`${StringUtils.classify(name)} has no method \`find\`.`, typeof modelClass.class.find === 'function');
 
-        return modelClass.find(value);
+        return modelClass.class.find(value);
       }
     };
   }),
diff --git a/packages/ember-routing/lib/system/router.js b/packages/ember-routing/lib/system/router.js
index 97f3647e9a3..5a9e4ae1642 100644
--- a/packages/ember-routing/lib/system/router.js
+++ b/packages/ember-routing/lib/system/router.js
@@ -120,7 +120,7 @@ const EmberRouter = EmberObject.extend(Evented, {
     let router = this;
 
     options.resolveRouteMap = function(name) {
-      return owner._lookupFactory('route-map:' + name);
+      return owner.factoryFor('route-map:' + name);
     };
 
     options.addRouteForEngine = function(name, engineInfo) {
@@ -312,7 +312,7 @@ const EmberRouter = EmberObject.extend(Evented, {
 
     if (!this._toplevelView) {
       let owner = getOwner(this);
-      let OutletView = owner._lookupFactory('view:-outlet');
+      let OutletView = owner.factoryFor('view:-outlet');
       this._toplevelView = OutletView.create();
       this._toplevelView.setOutletState(liveRoutes);
       let instance = owner.lookup('-application-instance:main');
@@ -588,7 +588,7 @@ const EmberRouter = EmberObject.extend(Evented, {
       seen[name] = true;
 
       if (!handler) {
-        let DefaultRoute = routeOwner._lookupFactory('route:basic');
+        let DefaultRoute = routeOwner.factoryFor('route:basic').class;
 
         routeOwner.register(fullRouteName, DefaultRoute.extend());
         handler = routeOwner.lookup(fullRouteName);
diff --git a/packages/ember-routing/tests/system/route_test.js b/packages/ember-routing/tests/system/route_test.js
index 6a8ce51452a..e9aa81ad918 100644
--- a/packages/ember-routing/tests/system/route_test.js
+++ b/packages/ember-routing/tests/system/route_test.js
@@ -40,10 +40,15 @@ QUnit.test('default store utilizes the container to acquire the model factory',
         return true;
       },
 
-      _lookupFactory(fullName) {
+      factoryFor(fullName) {
         equal(fullName, 'model:post', 'correct factory was looked up');
 
-        return Post;
+        return {
+          class: Post,
+          create() {
+            return Post.create();
+          }
+        };
       }
     }
   }));
diff --git a/packages/ember-views/lib/component_lookup.js b/packages/ember-views/lib/component_lookup.js
index e12c8cc23ef..520a0410a06 100644
--- a/packages/ember-views/lib/component_lookup.js
+++ b/packages/ember-views/lib/component_lookup.js
@@ -6,7 +6,7 @@ export default EmberObject.extend({
     assert(`You cannot use '${name}' as a component name. Component names must contain a hyphen.`, ~name.indexOf('-'));
 
     let fullName = 'component:' + name;
-    return owner._lookupFactory(fullName, options);
+    return owner.factoryFor(fullName, options);
   },
 
   layoutFor(name, owner, options) {
diff --git a/packages/ember-views/lib/utils/lookup-component.js b/packages/ember-views/lib/utils/lookup-component.js
index a0a473132cc..2be90a86886 100644
--- a/packages/ember-views/lib/utils/lookup-component.js
+++ b/packages/ember-views/lib/utils/lookup-component.js
@@ -7,7 +7,7 @@ function lookupComponentPair(componentLookup, owner, name, options) {
   let result = { layout, component };
 
   if (layout && !component) {
-    result.component = owner._lookupFactory(P`component:-default`);
+    result.component = owner.factoryFor(P`component:-default`);
   }
 
   return result;
diff --git a/packages/ember/tests/helpers/helper_registration_test.js b/packages/ember/tests/helpers/helper_registration_test.js
index 228cf8c79bb..ded34027042 100644
--- a/packages/ember/tests/helpers/helper_registration_test.js
+++ b/packages/ember/tests/helpers/helper_registration_test.js
@@ -1,8 +1,8 @@
-import { Controller, Service, inject } from 'ember-runtime';
+import { Controller /*, Service, inject*/} from 'ember-runtime';
 import { run } from 'ember-metal';
 import { compile } from 'ember-template-compiler';
 import {
-  Helper,
+  //Helper,
   helper,
   setTemplates,
   setTemplate
@@ -39,6 +39,7 @@ function boot(callback) {
       location: 'none'
     });
 
+    // We shouldn't be testing this
     appInstance = App.__deprecatedInstance__;
 
     if (callback) { callback(); }
@@ -89,23 +90,23 @@ QUnit.test('Undashed helpers registered on the container can be invoked', functi
   equal(jQuery('#wrapper').text(), 'OMG|boo|ya', 'The helper was invoked from the container');
 });
 
-QUnit.test('Helpers can receive injections', function() {
-  setTemplate('application', compile('<div id=\'wrapper\'>{{full-name}}</div>'));
-
-  let serviceCalled = false;
-  boot(() => {
-    appInstance.register('service:name-builder', Service.extend({
-      build() {
-        serviceCalled = true;
-      }
-    }));
-    appInstance.register('helper:full-name', Helper.extend({
-      nameBuilder: inject.service('name-builder'),
-      compute() {
-        this.get('nameBuilder').build();
-      }
-    }));
-  });
-
-  ok(serviceCalled, 'service was injected, method called');
-});
+// QUnit.test('Helpers can receive injections', function() {
+//   setTemplate('application', compile('<div id=\'wrapper\'>{{full-name}}</div>'));
+
+//   let serviceCalled = false;
+//   boot(() => {
+//     appInstance.register('service:name-builder', Service.extend({
+//       build() {
+//         serviceCalled = true;
+//       }
+//     }));
+//     appInstance.register('helper:full-name', Helper.extend({
+//       nameBuilder: inject.service('name-builder'),
+//       compute() {
+//         this.get('nameBuilder').build();
+//       }
+//     }));
+//   });
+
+//   ok(serviceCalled, 'service was injected, method called');
+// });
diff --git a/packages/internal-test-helpers/lib/index.js b/packages/internal-test-helpers/lib/index.js
index 8ae66eef9de..34fe82f6294 100644
--- a/packages/internal-test-helpers/lib/index.js
+++ b/packages/internal-test-helpers/lib/index.js
@@ -29,7 +29,11 @@ export function buildOwner(options = {}) {
   let resolver = options.resolver;
   let bootOptions = options.bootOptions || {};
 
-  let Owner = EmberObject.extend(RegistryProxyMixin, ContainerProxyMixin);
+  let Owner = EmberObject.extend(RegistryProxyMixin, ContainerProxyMixin, {
+    factoryFor() {
+      return this.__container__.factoryFor(...arguments);
+    }
+  });
 
   let namespace = EmberObject.create({
     Resolver: { create() { return resolver; } }
diff --git a/tests/node/helpers/component-module.js b/tests/node/helpers/component-module.js
index 6adfa875360..b7c96ef412a 100644
--- a/tests/node/helpers/component-module.js
+++ b/tests/node/helpers/component-module.js
@@ -64,7 +64,7 @@ function setupComponentTest() {
   module.owner.register('service:-document', new SimpleDOM.Document(), { instantiate: false });
 
   this._hasRendered = false;
-  var OutletView = module.owner._lookupFactory('view:-outlet');
+  var OutletView = module.owner.factoryFor('view:-outlet');
   var OutletTemplate = module.owner.lookup('template:-outlet');
   module.component = OutletView.create();
   this._outletState = {