diff --git a/core/src/main/java/hudson/ExtensionFinder.java b/core/src/main/java/hudson/ExtensionFinder.java
index ba8466d1dc32021497434826c963e33809955fde..9ac27f9892f724806d36a7e7dabf29e3f0784f2a 100644
--- a/core/src/main/java/hudson/ExtensionFinder.java
+++ b/core/src/main/java/hudson/ExtensionFinder.java
@@ -40,6 +40,7 @@ import hudson.model.Descriptor;
 import hudson.model.Hudson;
 import jenkins.ExtensionComponentSet;
 import jenkins.ExtensionRefreshException;
+import jenkins.ProxyInjector;
 import jenkins.model.Jenkins;
 import net.java.sezpoz.Index;
 import net.java.sezpoz.IndexItem;
@@ -183,6 +184,13 @@ public abstract class ExtensionFinder implements ExtensionPoint {
     public static final class GuiceFinder extends AbstractGuiceFinder<Extension> {
         public GuiceFinder() {
             super(Extension.class);
+
+            // expose Injector via lookup mechanism for interop with non-Guice clients
+            Jenkins.getInstance().lookup.set(Injector.class,new ProxyInjector() {
+                protected Injector resolve() {
+                    return getContainer();
+                }
+            });
         }
 
         @Override
@@ -207,7 +215,7 @@ public abstract class ExtensionFinder implements ExtensionPoint {
          * a child container to house newly discovered components. This field points to the
          * youngest such container.
          */
-        private Injector container;
+        private volatile Injector container;
 
         /**
          * Sezpoz index we are currently using in {@link #container} (and its ancestors.)
@@ -242,6 +250,10 @@ public abstract class ExtensionFinder implements ExtensionPoint {
             }
         }
 
+        public Injector getContainer() {
+            return container;
+        }
+
         /**
          * The basic idea is:
          *
diff --git a/core/src/main/java/hudson/PluginManager.java b/core/src/main/java/hudson/PluginManager.java
index 8c0e9f332c9eb789902a2affb4e6605489814c9b..2b05a8202e2103b4601761c332bfddda7afe2476 100644
--- a/core/src/main/java/hudson/PluginManager.java
+++ b/core/src/main/java/hudson/PluginManager.java
@@ -282,8 +282,6 @@ public abstract class PluginManager extends AbstractModelObject {
                     Jenkins.getInstance().lookup.set(PluginInstanceStore.class,new PluginInstanceStore());
                     TaskGraphBuilder g = new TaskGraphBuilder();
 
-                    Jenkins.getInstance().lookup.set(Injector.class,Guice.createInjector());
-
                     // schedule execution of loading plugins
                     for (final PluginWrapper p : activePlugins.toArray(new PluginWrapper[activePlugins.size()])) {
                         g.followedBy().notFatal().attains(PLUGINS_PREPARED).add("Loading plugin " + p.getShortName(), new Executable() {
diff --git a/core/src/main/java/jenkins/ProxyInjector.java b/core/src/main/java/jenkins/ProxyInjector.java
new file mode 100644
index 0000000000000000000000000000000000000000..abf66da06a2516c59ee83f4cc8b9bc5e3a72fe79
--- /dev/null
+++ b/core/src/main/java/jenkins/ProxyInjector.java
@@ -0,0 +1,120 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2011, CloudBees, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package jenkins;
+
+import com.google.inject.Binding;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.MembersInjector;
+import com.google.inject.Module;
+import com.google.inject.Provider;
+import com.google.inject.Scope;
+import com.google.inject.TypeLiteral;
+import com.google.inject.spi.TypeConverterBinding;
+
+import java.lang.annotation.Annotation;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * {@link Injector} that delegates to another one.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+public abstract class ProxyInjector implements Injector {
+    protected abstract Injector resolve();
+
+    public void injectMembers(Object instance) {
+        resolve().injectMembers(instance);
+    }
+
+    public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
+        return resolve().getMembersInjector(typeLiteral);
+    }
+
+    public <T> MembersInjector<T> getMembersInjector(Class<T> type) {
+        return resolve().getMembersInjector(type);
+    }
+
+    public Map<Key<?>, Binding<?>> getBindings() {
+        return resolve().getBindings();
+    }
+
+    public Map<Key<?>, Binding<?>> getAllBindings() {
+        return resolve().getAllBindings();
+    }
+
+    public <T> Binding<T> getBinding(Key<T> key) {
+        return resolve().getBinding(key);
+    }
+
+    public <T> Binding<T> getBinding(Class<T> type) {
+        return resolve().getBinding(type);
+    }
+
+    public <T> Binding<T> getExistingBinding(Key<T> key) {
+        return resolve().getExistingBinding(key);
+    }
+
+    public <T> List<Binding<T>> findBindingsByType(TypeLiteral<T> type) {
+        return resolve().findBindingsByType(type);
+    }
+
+    public <T> Provider<T> getProvider(Key<T> key) {
+        return resolve().getProvider(key);
+    }
+
+    public <T> Provider<T> getProvider(Class<T> type) {
+        return resolve().getProvider(type);
+    }
+
+    public <T> T getInstance(Key<T> key) {
+        return resolve().getInstance(key);
+    }
+
+    public <T> T getInstance(Class<T> type) {
+        return resolve().getInstance(type);
+    }
+
+    public Injector getParent() {
+        return resolve().getParent();
+    }
+
+    public Injector createChildInjector(Iterable<? extends Module> modules) {
+        return resolve().createChildInjector(modules);
+    }
+
+    public Injector createChildInjector(Module... modules) {
+        return resolve().createChildInjector(modules);
+    }
+
+    public Map<Class<? extends Annotation>, Scope> getScopeBindings() {
+        return resolve().getScopeBindings();
+    }
+
+    public Set<TypeConverterBinding> getTypeConverterBindings() {
+        return resolve().getTypeConverterBindings();
+    }
+}