diff --git a/lib/vagrant.rb b/lib/vagrant.rb
index 1e160ab47..c7fd558a3 100644
--- a/lib/vagrant.rb
+++ b/lib/vagrant.rb
@@ -80,7 +80,6 @@ module Vagrant
   autoload :TestHelpers,   'vagrant/test_helpers'
   autoload :UI,            'vagrant/ui'
   autoload :Util,          'vagrant/util'
-  autoload :VM,            'vagrant/vm'
 
   # These are the various plugin versions and their components in
   # a lazy loaded Hash-like structure.
diff --git a/lib/vagrant/vm.rb b/lib/vagrant/vm.rb
deleted file mode 100644
index d35c25535..000000000
--- a/lib/vagrant/vm.rb
+++ /dev/null
@@ -1,205 +0,0 @@
-require 'log4r'
-
-module Vagrant
-  class VM
-    include Vagrant::Util
-
-    attr_reader :uuid
-    attr_reader :env
-    attr_reader :name
-    attr_reader :vm
-    attr_reader :box
-    attr_reader :config
-    attr_reader :driver
-
-    def initialize(name, env, config, opts=nil)
-      @logger = Log4r::Logger.new("vagrant::vm")
-
-      @name   = name
-      @vm     = nil
-      @env    = env
-      @config = config
-      @box    = nil
-      @box    = env.boxes.find(config.vm.box, :virtualbox) if config.vm.box
-
-      opts ||= {}
-      if opts[:base]
-        # The name is the ID we use.
-        @uuid = name
-      else
-        # Load the UUID if its saved.
-        active = env.local_data[:active] || {}
-        @uuid = active[@name.to_s]
-      end
-
-      # Reload ourselves to get the state
-      reload!
-
-      # Load the associated guest.
-      load_guest!
-      @loaded_guest_distro = false
-    end
-
-    # Loads the guest associated with the VM. The guest class is
-    # responsible for OS-specific functionality. More information
-    # can be found by reading the documentation on {Vagrant::Guest::Base}.
-    #
-    # **This method should never be called manually.**
-    def load_guest!(guest=nil)
-      guest ||= config.vm.guest
-      @logger.info("Loading guest: #{guest}")
-
-      if guest.is_a?(Class)
-        raise Errors::VMGuestError, :_key => :invalid_class, :guest => guest.to_s if !(guest <= Vagrant.plugin("1", :guest))
-        @guest = guest.new(self)
-      elsif guest.is_a?(Symbol)
-        # Look for the guest as a registered plugin
-        guest_klass = nil
-        Vagrant.plugin("1").registered.each do |plugin|
-          if plugin.guest.has_key?(guest)
-            guest_klass = plugin.guest[guest]
-            break
-          end
-        end
-
-        raise Errors::VMGuestError, :_key => :unknown_type, :guest => guest.to_s if !guest_klass
-        @guest = guest_klass.new(self)
-      else
-        raise Errors::VMGuestError, :unspecified
-      end
-    end
-
-    # Returns a channel object to communicate with the virtual
-    # machine.
-    def channel
-      @channel ||= Communication::SSH.new(self)
-    end
-
-    # Returns the guest for this VM, loading the distro of the system if
-    # we can.
-    def guest
-      if !@loaded_guest_distro && state == :running
-        # Load the guest distro for the first time
-        result = @guest.distro_dispatch
-        load_guest!(result)
-        @loaded_guest_distro = true
-        @logger.info("Guest class: #{@guest.class}")
-      end
-
-      @guest
-    end
-
-    # Access the {Vagrant::SSH} object associated with this VM, which
-    # is used to get SSH credentials with the virtual machine.
-    def ssh
-      @ssh ||= SSH.new(self)
-    end
-
-    # Returns the state of the VM as a symbol.
-    #
-    # @return [Symbol]
-    def state
-      return :not_created if !@uuid
-      state = @driver.read_state
-      return :not_created if !state
-      return state
-    end
-
-    # Returns a boolean true if the VM has been created, otherwise
-    # returns false.
-    #
-    # @return [Boolean]
-    def created?
-      state != :not_created
-    end
-
-    # Sets the currently active VM for this VM. If the VM is a valid,
-    # created virtual machine, then it will also update the local data
-    # to persist the VM. Otherwise, it will remove itself from the
-    # local data (if it exists).
-    def uuid=(value)
-      env.local_data[:active] ||= {}
-      if value
-        env.local_data[:active][name.to_s] = value
-      else
-        env.local_data[:active].delete(name.to_s)
-      end
-
-      # Commit the local data so that the next time vagrant is initialized,
-      # it realizes the VM exists
-      env.local_data.commit
-
-      # Store the uuid and reload the instance
-      @uuid = value
-      reload!
-    end
-
-    def reload!
-      begin
-        @driver = Driver::VirtualBox.new(@uuid)
-      rescue Driver::VirtualBox::VMNotFound
-        # Clear the UUID since this VM doesn't exist.
-        @uuid = nil
-
-        # Reset the driver. This shouldn't raise a VMNotFound since we won't
-        # feed it a UUID.
-        @driver = Driver::VirtualBox.new
-      end
-    end
-
-    def package(options=nil)
-      run_action(:package, { "validate" => false }.merge(options || {}))
-    end
-
-    def up(options=nil)
-      run_action(:up, options)
-    end
-
-    def start(options=nil)
-      return if state == :running
-      return resume if state == :saved
-
-      run_action(:start, options)
-    end
-
-    def halt(options=nil)
-      run_action(:halt, options)
-    end
-
-    def reload(options=nil)
-      run_action(:reload, options)
-    end
-
-    def provision
-      run_action(:provision)
-    end
-
-    def destroy
-      run_action(:destroy)
-    end
-
-    def suspend
-      run_action(:suspend)
-    end
-
-    def resume
-      run_action(:resume)
-    end
-
-    def ui
-      return @_ui if defined?(@_ui)
-      @_ui = @env.ui.dup
-      @_ui.resource = @name
-      @_ui
-    end
-
-    def run_action(name, options=nil)
-      options = {
-        :vm => self,
-        :ui => ui
-      }.merge(options || {})
-
-      env.action_runner.run(name, options)
-    end
-  end
-end