diff --git a/Makefile b/Makefile
index 0dc1df911..d4b86457e 100644
--- a/Makefile
+++ b/Makefile
@@ -115,6 +115,7 @@ endif
 	$(call build_binary,infrakit,github.com/docker/infrakit/cmd/cli)
 	$(call build_binary,infrakit-manager,github.com/docker/infrakit/cmd/manager)
 	$(call build_binary,infrakit-group-default,github.com/docker/infrakit/cmd/group)
+	$(call build_binary,infrakit-resource,github.com/docker/infrakit/cmd/resource)
 	$(call build_binary,infrakit-flavor-combo,github.com/docker/infrakit/examples/flavor/combo)
 	$(call build_binary,infrakit-flavor-swarm,github.com/docker/infrakit/examples/flavor/swarm)
 	$(call build_binary,infrakit-flavor-vanilla,github.com/docker/infrakit/examples/flavor/vanilla)
diff --git a/cmd/cli/main.go b/cmd/cli/main.go
index 1716e0046..3a8aac0d5 100644
--- a/cmd/cli/main.go
+++ b/cmd/cli/main.go
@@ -47,7 +47,7 @@ func main() {
 	cmd.AddCommand(eventCommand(f))
 	cmd.AddCommand(pluginCommand(f))
 
-	cmd.AddCommand(instancePluginCommand(f), groupPluginCommand(f), flavorPluginCommand(f))
+	cmd.AddCommand(instancePluginCommand(f), groupPluginCommand(f), flavorPluginCommand(f), resourcePluginCommand(f))
 
 	err := cmd.Execute()
 	if err != nil {
diff --git a/cmd/cli/resource.go b/cmd/cli/resource.go
new file mode 100644
index 000000000..dee97282e
--- /dev/null
+++ b/cmd/cli/resource.go
@@ -0,0 +1,168 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/docker/infrakit/pkg/discovery"
+	"github.com/docker/infrakit/pkg/plugin"
+	resource_plugin "github.com/docker/infrakit/pkg/rpc/resource"
+	"github.com/docker/infrakit/pkg/spi/resource"
+	"github.com/docker/infrakit/pkg/template"
+	"github.com/docker/infrakit/pkg/types"
+	"github.com/spf13/cobra"
+)
+
+func resourcePluginCommand(plugins func() discovery.Plugins) *cobra.Command {
+
+	var resourcePlugin resource.Plugin
+
+	cmd := &cobra.Command{
+		Use:   "resource",
+		Short: "Access resource plugin",
+	}
+	name := cmd.PersistentFlags().String("name", "resource", "Name of plugin")
+	cmd.PersistentPreRunE = func(c *cobra.Command, args []string) error {
+		if err := upTree(c, func(x *cobra.Command, argv []string) error {
+			if x.PersistentPreRunE != nil {
+				return x.PersistentPreRunE(x, argv)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+
+		endpoint, err := plugins().Find(plugin.Name(*name))
+		if err != nil {
+			return err
+		}
+
+		p, err := resource_plugin.NewClient(endpoint.Address)
+		if err != nil {
+			return err
+		}
+		resourcePlugin = p
+		return nil
+	}
+
+	commit := cobra.Command{
+		Use:   "commit <template URL>",
+		Short: "commit a resource configuration specified by the URL",
+	}
+	commitPretend := commit.Flags().Bool("pretend", false, "Don't actually commit, only explain the commit")
+	commit.RunE = func(cmd *cobra.Command, args []string) error {
+		assertNotNil("no plugin", resourcePlugin)
+
+		if len(args) != 1 {
+			cmd.Usage()
+			os.Exit(1)
+		}
+
+		spec, err := readSpecFromTemplateURL(args[0])
+		if err != nil {
+			return err
+		}
+
+		details, err := resourcePlugin.Commit(*spec, *commitPretend)
+		if err == nil {
+			if *commitPretend {
+				fmt.Printf("Committing %s would involve:\n%s\n", spec.ID, details)
+			} else {
+				fmt.Printf("Committed %s:\n%s\n", spec.ID, details)
+			}
+		}
+		return err
+	}
+	cmd.AddCommand(&commit)
+
+	destroy := cobra.Command{
+		Use:   "destroy <template URL>",
+		Short: "destroy a resource configuration specified by the URL",
+	}
+	destroyPretend := destroy.Flags().Bool("pretend", false, "Don't actually destroy, only explain the destroy")
+	destroy.RunE = func(cmd *cobra.Command, args []string) error {
+		assertNotNil("no plugin", resourcePlugin)
+
+		if len(args) != 1 {
+			cmd.Usage()
+			os.Exit(1)
+		}
+
+		spec, err := readSpecFromTemplateURL(args[0])
+		if err != nil {
+			return err
+		}
+
+		details, err := resourcePlugin.Destroy(*spec, *destroyPretend)
+		if err == nil {
+			if *destroyPretend {
+				fmt.Printf("Destroying %s would involve:\n%s\n", spec.ID, details)
+			} else {
+				fmt.Printf("Destroyed %s:\n%s\n", spec.ID, details)
+			}
+		}
+		return err
+	}
+	cmd.AddCommand(&destroy)
+
+	describe := cobra.Command{
+		Use:   "describe <template URL>",
+		Short: "describe a resource configuration specified by the URL",
+	}
+	describe.RunE = func(cmd *cobra.Command, args []string) error {
+		assertNotNil("no plugin", resourcePlugin)
+
+		if len(args) != 1 {
+			cmd.Usage()
+			os.Exit(1)
+		}
+
+		spec, err := readSpecFromTemplateURL(args[0])
+		if err != nil {
+			return err
+		}
+
+		details, err := resourcePlugin.DescribeResources(*spec)
+		if err == nil {
+			if len(details) > 0 {
+				fmt.Println(details)
+			}
+		}
+		return err
+	}
+	cmd.AddCommand(&describe)
+
+	return cmd
+}
+
+func readSpecFromTemplateURL(templateURL string) (*resource.Spec, error) {
+	log.Infof("Reading template from %v", templateURL)
+	engine, err := template.NewTemplate(templateURL, template.Options{
+		SocketDir: discovery.Dir(),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	engine.WithFunctions(func() []template.Function {
+		return []template.Function{
+			{Name: "resource", Func: func(s string) string { return fmt.Sprintf("{{ resource `%s` }}", s) }},
+		}
+	})
+
+	view, err := engine.Render(nil)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Debugln(view)
+
+	spec := resource.Spec{}
+	if err := types.AnyString(view).Decode(&spec); err != nil {
+		log.Warningln("Error parsing template")
+		return nil, err
+	}
+
+	return &spec, nil
+}
diff --git a/cmd/resource/README.md b/cmd/resource/README.md
new file mode 100644
index 000000000..e3ccec945
--- /dev/null
+++ b/cmd/resource/README.md
@@ -0,0 +1,69 @@
+InfraKit Resource Plugin
+========================
+
+The Resource plugin works in conjuction with Instance plugins to manage collections of
+interdependent, named resources.  Dependencies are expressed with the `resource "name"` template
+function, the output of which is the ID of the named resource.
+
+## Running
+
+Begin by building plugin [binaries](../../README.md#binaries).
+
+The plugin may be started without any arguments and will default to using unix socket in
+`~/.infrakit/plugins` for communications with the CLI and other plugins:
+
+```shell
+$ build/infrakit-resource
+INFO[0000] Listening at: ~/.infrakit/plugins/resource
+```
+
+## Working with the Resource Plugin
+
+Start the resource plugin as show above.
+
+Start the `instance-file` plugin:
+```shell
+$ mkdir -p instances
+$ build/infrakit-instance-file --dir instances
+INFO[0000] Listening at: ~/.infrakit/plugins/instance-file
+INFO[0000] PID file at ~/.infrakit/plugins/instance-file.pid
+```
+
+Save the following in a file named resources.json.
+```json
+{
+  "ID": "Fancy Resources",
+  "Properties": {
+    "Resources": [
+      {
+        "ID": "A",
+        "Plugin": "instance-file",
+        "Properties": {}
+      },
+      {
+        "ID": "B",
+        "Plugin": "instance-file",
+        "Properties": {
+          "Note": "Depends on {{ resource `A` }}"
+        }
+      }
+    ]
+  }
+}
+```
+
+Commit resources.json:
+```shell
+$ build/infrakit resource commit file:$PWD/resources.json
+INFO[0000] Reading template from file:~/resources.json
+Committed Fancy Resources:
+Provisioned A (instance-9021654729849995625)
+Provisioned B (instance-2978607024592968517)
+```
+
+Verify the presence of `A`'s ID in `B`:
+
+```shell
+$ jq .Spec.Properties.Note instances/instance-2978607024592968517
+"Depends on instance-9021654729849995625"
+```
diff --git a/cmd/resource/main.go b/cmd/resource/main.go
new file mode 100644
index 000000000..96d397a79
--- /dev/null
+++ b/cmd/resource/main.go
@@ -0,0 +1,57 @@
+package main
+
+import (
+	"os"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/docker/infrakit/pkg/cli"
+	"github.com/docker/infrakit/pkg/discovery"
+	"github.com/docker/infrakit/pkg/plugin"
+	"github.com/docker/infrakit/pkg/plugin/resource"
+	instance_client "github.com/docker/infrakit/pkg/rpc/instance"
+	resource_server "github.com/docker/infrakit/pkg/rpc/resource"
+	"github.com/docker/infrakit/pkg/spi/instance"
+	"github.com/spf13/cobra"
+)
+
+func main() {
+
+	cmd := &cobra.Command{
+		Use:   os.Args[0],
+		Short: "Resource server",
+	}
+	name := cmd.Flags().String("name", "resource", "Plugin name to advertise for discovery")
+	logLevel := cmd.Flags().Int("log", cli.DefaultLogLevel, "Logging level. 0 is least verbose. Max is 5")
+
+	cmd.RunE = func(c *cobra.Command, args []string) error {
+
+		cli.SetLogLevel(*logLevel)
+
+		plugins, err := discovery.NewPluginDiscovery()
+		if err != nil {
+			return err
+		}
+
+		instancePluginLookup := func(n plugin.Name) (instance.Plugin, error) {
+			endpoint, err := plugins.Find(n)
+			if err != nil {
+				return nil, err
+			}
+			return instance_client.NewClient(n, endpoint.Address)
+		}
+
+		resourcePlugin := resource.NewResourcePlugin(instancePluginLookup)
+
+		cli.RunPlugin(*name, resource_server.PluginServer(resourcePlugin))
+
+		return nil
+	}
+
+	cmd.AddCommand(cli.VersionCommand())
+
+	err := cmd.Execute()
+	if err != nil {
+		log.Error(err)
+		os.Exit(1)
+	}
+}
diff --git a/pkg/plugin/resource/plugin.go b/pkg/plugin/resource/plugin.go
new file mode 100644
index 000000000..20a9805dd
--- /dev/null
+++ b/pkg/plugin/resource/plugin.go
@@ -0,0 +1,330 @@
+package resource
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/docker/infrakit/pkg/discovery"
+	plugin_base "github.com/docker/infrakit/pkg/plugin"
+	"github.com/docker/infrakit/pkg/spi/instance"
+	"github.com/docker/infrakit/pkg/spi/resource"
+	"github.com/docker/infrakit/pkg/template"
+	"github.com/docker/infrakit/pkg/types"
+	"github.com/twmb/algoimpl/go/graph"
+)
+
+const (
+	resourcesTag   = "infrakit.resources"
+	resourcesIDTag = "infrakit.resources.id"
+)
+
+// Spec is the configuration schema for this plugin, provided in resource.Spec.Properties.
+type Spec struct {
+	Resources []struct {
+		ID         string
+		Plugin     plugin_base.Name
+		Properties *types.Any
+	}
+}
+
+// InstancePluginLookup looks up a plugin by name.
+type InstancePluginLookup func(plugin_base.Name) (instance.Plugin, error)
+
+// NewResourcePlugin creates a new resource plugin.
+func NewResourcePlugin(instancePluginLookup InstancePluginLookup) resource.Plugin {
+	return &plugin{
+		instancePluginLookup: instancePluginLookup,
+	}
+}
+
+type plugin struct {
+	instancePluginLookup InstancePluginLookup
+}
+
+type resourceConfig struct {
+	plugin     instance.Plugin
+	properties string
+}
+
+func (p *plugin) Commit(config resource.Spec, pretend bool) (string, error) {
+	resourceConfigs, provisioningOrder, err := validate(config, p.instancePluginLookup)
+	if err != nil {
+		return "", err
+	}
+
+	log.Infof("Committing %s (pretend=%t)", config.ID, pretend)
+
+	instanceIDs, err := describe(config.ID, resourceConfigs)
+	if err != nil {
+		return "", err
+	}
+
+	resourceTemplateFunc := func(name string) (string, error) {
+		if id, ok := instanceIDs[name]; ok {
+			return string(id), nil
+		}
+		return "", fmt.Errorf("Undefined resource '%s'", name)
+	}
+
+	details := []string{}
+	for _, name := range provisioningOrder {
+		if id, ok := instanceIDs[name]; ok {
+			details = append(details, fmt.Sprintf("Found %s (%s)", name, id))
+			continue
+		}
+
+		template, err := template.NewTemplate("str://"+resourceConfigs[name].properties, template.Options{SocketDir: discovery.Dir()})
+		if err != nil {
+			return "", fmt.Errorf("Failed to parse template '%s' for resource '%s': %s", resourceConfigs[name].properties, name, err)
+		}
+
+		properties, err := template.AddFunc("resource", resourceTemplateFunc).Render(nil)
+		if err != nil {
+			return "", fmt.Errorf("Failed to execute template '%s' for resource '%s': %s", resourceConfigs[name].properties, name, err)
+		}
+
+		detail := ""
+		if pretend {
+			instanceIDs[name] = instance.ID("unknown")
+
+			detail = fmt.Sprintf("Would provision %s", name)
+		} else {
+			id, err := resourceConfigs[name].plugin.Provision(instance.Spec{
+				Properties: types.AnyString(properties),
+				Tags: map[string]string{
+					resourcesTag:   string(config.ID),
+					resourcesIDTag: name,
+				},
+			})
+			if err != nil {
+				return "", fmt.Errorf("Failed to provision resource '%s': %s", name, err)
+			}
+			instanceIDs[name] = *id
+
+			detail = fmt.Sprintf("Provisioned %s (%s)", name, *id)
+			log.Info(detail)
+		}
+
+		details = append(details, detail)
+	}
+
+	sort.Strings(details)
+	return strings.Join(details, "\n"), nil
+}
+
+func (p *plugin) Destroy(config resource.Spec, pretend bool) (string, error) {
+	resourceConfigs, provisioningOrder, err := validate(config, p.instancePluginLookup)
+	if err != nil {
+		return "", err
+	}
+
+	log.Infof("Destroying %s (pretend=%t)", config.ID, pretend)
+
+	instanceIDs, err := describe(config.ID, resourceConfigs)
+	if err != nil {
+		return "", err
+	}
+
+	details := []string{}
+
+	// Traverse provisioningOrder in reverse.
+	for i := len(provisioningOrder) - 1; i >= 0; i-- {
+		name := provisioningOrder[i]
+
+		id, ok := instanceIDs[name]
+		if !ok {
+			continue
+		}
+
+		detail := ""
+		if pretend {
+			detail = fmt.Sprintf("Would destroy %s (%s)", name, id)
+		} else {
+			if err = resourceConfigs[name].plugin.Destroy(id); err != nil {
+				return "", fmt.Errorf("Failed to destroy resource '%s' (%s): %s", name, id, err)
+			}
+
+			detail = fmt.Sprintf("Destroyed %s (%s)", name, id)
+			log.Infof(detail)
+		}
+
+		details = append(details, detail)
+	}
+
+	sort.Strings(details)
+	return strings.Join(details, "\n"), nil
+}
+
+func (p *plugin) DescribeResources(config resource.Spec) (string, error) {
+	resourceConfigs, _, err := validate(config, p.instancePluginLookup)
+	if err != nil {
+		return "", err
+	}
+
+	log.Infof("Describing %s", config.ID)
+
+	instanceIDs, err := describe(config.ID, resourceConfigs)
+	if err != nil {
+		return "", err
+	}
+
+	details := []string{}
+	for name, id := range instanceIDs {
+		details = append(details, fmt.Sprintf("Found %s (%s)", name, id))
+	}
+
+	sort.Strings(details)
+	return strings.Join(details, "\n"), nil
+}
+
+func describe(id resource.ID, resourceConfigs map[string]resourceConfig) (map[string]instance.ID, error) {
+	instanceIDs := map[string]instance.ID{}
+
+	for name, resourceConfig := range resourceConfigs {
+		descriptions, err := resourceConfig.plugin.DescribeInstances(map[string]string{
+			resourcesTag:   string(id),
+			resourcesIDTag: name,
+		})
+		if err != nil {
+			return nil, fmt.Errorf("Failed to describe resource '%s': %s", name, err)
+		}
+
+		switch len(descriptions) {
+		case 0:
+			break
+		case 1:
+			instanceIDs[name] = descriptions[0].ID
+			log.Infof("Found %s (%s)'", name, descriptions[0].ID)
+		default:
+			ids := []instance.ID{}
+			for _, d := range descriptions {
+				ids = append(ids, d.ID)
+			}
+			return nil, fmt.Errorf("Found multiple instance IDs for resource '%s': %v", name, ids)
+		}
+	}
+
+	return instanceIDs, nil
+}
+
+func validate(config resource.Spec, instancePluginLookup InstancePluginLookup) (map[string]resourceConfig, []string, error) {
+	if config.ID == "" {
+		return nil, nil, errors.New("ID must be set")
+	}
+
+	if config.Properties == nil {
+		return nil, nil, errors.New("Properties must be set")
+	}
+
+	spec := Spec{}
+	if err := config.Properties.Decode(&spec); err != nil {
+		return nil, nil, fmt.Errorf("Invalid properties '%s': %s", config.Properties, err)
+	}
+
+	resourceConfigs := map[string]resourceConfig{}
+	for _, resourceSpec := range spec.Resources {
+		if resourceSpec.ID == "" {
+			return nil, nil, errors.New("Resource ID must be set")
+		}
+
+		if _, ok := resourceConfigs[resourceSpec.ID]; ok {
+			return nil, nil, fmt.Errorf("Duplicate resource ID '%s'", resourceSpec.ID)
+		}
+
+		instancePlugin, err := instancePluginLookup(resourceSpec.Plugin)
+		if err != nil {
+			return nil, nil, fmt.Errorf("Failed to find plugin '%s' for resource '%s': %s", resourceSpec.Plugin, resourceSpec.ID, err)
+		}
+
+		if resourceSpec.Properties == nil {
+			return nil, nil, fmt.Errorf("Properties must be set for resource '%s'", resourceSpec.ID)
+		}
+
+		if err := instancePlugin.Validate(resourceSpec.Properties); err != nil {
+			return nil, nil, fmt.Errorf("Failed to validate spec '%s' for resource '%s': %s", resourceSpec.Properties, resourceSpec.ID, err)
+		}
+
+		resourceConfigs[resourceSpec.ID] = resourceConfig{
+			plugin:     instancePlugin,
+			properties: resourceSpec.Properties.String(),
+		}
+	}
+
+	provisioningOrder, err := getProvisioningOrder(resourceConfigs)
+	if err != nil {
+		return nil, nil, err
+	}
+	log.Infof("Provisioning order: %s", provisioningOrder)
+
+	return resourceConfigs, provisioningOrder, nil
+}
+
+func getProvisioningOrder(resourceConfigs map[string]resourceConfig) ([]string, error) {
+	g := graph.New(graph.Directed)
+
+	nodes := map[string]graph.Node{}
+	for name := range resourceConfigs {
+		nodes[name] = g.MakeNode()
+		*nodes[name].Value = name
+	}
+
+	for name, resourceConfig := range resourceConfigs {
+		template, err := template.NewTemplate("str://"+resourceConfig.properties, template.Options{SocketDir: discovery.Dir()})
+		if err != nil {
+			return nil, fmt.Errorf("Failed to parse template for resource '%s': %s", name, err)
+		}
+
+		dependencies, err := getResourceDependencies(template)
+		if err != nil {
+			return nil, fmt.Errorf("Failed to get dependencies for resource '%s': %s", name, err)
+		}
+
+		to := nodes[name]
+		for dependency := range dependencies {
+			from, ok := nodes[dependency]
+			if !ok {
+				return nil, fmt.Errorf("Resource '%s' depends on undefined resource '%s'", name, dependency)
+			}
+			if from == to {
+				return nil, fmt.Errorf("Resource '%s' depends on itself", name)
+			}
+			if err := g.MakeEdge(from, to); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	for _, connectedComponent := range g.StronglyConnectedComponents() {
+		if len(connectedComponent) > 1 {
+			var cycle []string
+			for _, node := range connectedComponent {
+				cycle = append(cycle, (*node.Value).(string))
+			}
+			sort.Strings(cycle)
+			return nil, fmt.Errorf("Cycle detected: %v", cycle)
+		}
+	}
+
+	order := []string{}
+	for _, node := range g.TopologicalSort() {
+		order = append(order, (*node.Value).(string))
+	}
+
+	return order, nil
+}
+
+func getResourceDependencies(template *template.Template) (map[string]bool, error) {
+	dependencies := map[string]bool{}
+	resourceTemplateFunc := func(name string) string {
+		dependencies[name] = true
+		return ""
+	}
+	if _, err := template.AddFunc("resource", resourceTemplateFunc).Render(nil); err != nil {
+		return nil, err
+	}
+
+	return dependencies, nil
+}
diff --git a/pkg/plugin/resource/plugin_test.go b/pkg/plugin/resource/plugin_test.go
new file mode 100644
index 000000000..5a1a9fddd
--- /dev/null
+++ b/pkg/plugin/resource/plugin_test.go
@@ -0,0 +1,405 @@
+package resource
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/docker/infrakit/pkg/discovery"
+	plugin_base "github.com/docker/infrakit/pkg/plugin"
+	"github.com/docker/infrakit/pkg/plugin/group/util"
+	"github.com/docker/infrakit/pkg/spi/instance"
+	"github.com/docker/infrakit/pkg/spi/resource"
+	"github.com/docker/infrakit/pkg/template"
+	testing_instance "github.com/docker/infrakit/pkg/testing/instance"
+	"github.com/docker/infrakit/pkg/types"
+	"github.com/stretchr/testify/require"
+)
+
+func newTestInstancePlugin() *testing_instance.Plugin {
+	idPrefix := util.RandomAlphaNumericString(4)
+	nextID := 0
+	instances := map[instance.ID]instance.Spec{}
+
+	return &testing_instance.Plugin{
+		DoValidate: func(req *types.Any) error {
+			return nil
+		},
+		DoProvision: func(spec instance.Spec) (*instance.ID, error) {
+			id := instance.ID(fmt.Sprintf("%s-%d", idPrefix, nextID))
+			nextID++
+			instances[id] = spec
+			return &id, nil
+		},
+		DoDestroy: func(id instance.ID) error {
+			if _, ok := instances[id]; !ok {
+				return errors.New("Instance does not exist")
+			}
+			delete(instances, id)
+			return nil
+		},
+		DoDescribeInstances: func(tags map[string]string) ([]instance.Description, error) {
+			descriptions := []instance.Description{}
+		Loop:
+			for id, inst := range instances {
+				for k, v := range tags {
+					if v2, ok := inst.Tags[k]; !ok || v2 != v {
+						continue Loop
+					}
+				}
+				descriptions = append(descriptions, instance.Description{
+					ID:        id,
+					LogicalID: inst.LogicalID,
+					Tags:      inst.Tags,
+				})
+			}
+			return descriptions, nil
+		},
+	}
+}
+
+const configID = "config"
+const resourcesJSON = `
+{
+  "Resources": [
+    {"ID": "a", "Plugin": "pluginA", "Properties": "{{ resource ` + "`b`" + ` }}"},
+    {"ID": "b", "Plugin": "pluginB", "Properties": ""}
+  ]
+}`
+
+func TestCommitAndDestroy(t *testing.T) {
+	instancePluginA := newTestInstancePlugin()
+	instancePluginB := newTestInstancePlugin()
+
+	p := NewResourcePlugin(func(name plugin_base.Name) (instance.Plugin, error) {
+		switch name {
+		case "pluginA":
+			return instancePluginA, nil
+		case "pluginB":
+			return instancePluginB, nil
+		}
+		return nil, errors.New("not found")
+	})
+
+	spec := resource.Spec{
+		ID:         configID,
+		Properties: types.AnyString(resourcesJSON),
+	}
+
+	// Commit when pretend is true should create no resources.
+	_, err := p.Commit(spec, true)
+	require.NoError(t, err)
+
+	descriptions, err := instancePluginA.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 0)
+
+	descriptions, err = instancePluginB.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 0)
+
+	// Commit when pretend is false should create resources.
+	_, err = p.Commit(spec, false)
+	require.NoError(t, err)
+
+	descriptions, err = instancePluginA.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 1)
+
+	require.NotEqual(t, "", descriptions[0].ID)
+	require.Nil(t, descriptions[0].LogicalID)
+	require.Equal(t, map[string]string{resourcesTag: configID, resourcesIDTag: "a"}, descriptions[0].Tags)
+
+	descriptions, err = instancePluginB.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 1)
+
+	require.NotEqual(t, "", descriptions[0].ID)
+	require.Nil(t, descriptions[0].LogicalID)
+	require.Equal(t, map[string]string{resourcesTag: configID, resourcesIDTag: "b"}, descriptions[0].Tags)
+
+	// Commit with the same specification should create no additional resources.
+	_, err = p.Commit(spec, false)
+	require.NoError(t, err)
+
+	descriptions, err = instancePluginA.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 1)
+
+	descriptions, err = instancePluginB.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 1)
+
+	// Destroy when pretend is true should detroy no resources.
+	_, err = p.Destroy(spec, true)
+	require.NoError(t, err)
+
+	descriptions, err = instancePluginA.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 1)
+
+	descriptions, err = instancePluginB.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 1)
+
+	// Destroy when pretend is false should destroy resources.
+	_, err = p.Destroy(spec, false)
+	require.NoError(t, err)
+
+	descriptions, err = instancePluginA.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 0)
+
+	descriptions, err = instancePluginB.DescribeInstances(nil)
+	require.NoError(t, err)
+	require.Len(t, descriptions, 0)
+
+	// Destroy with the same specification should succeed.
+	_, err = p.Destroy(spec, false)
+	require.NoError(t, err)
+}
+
+func TestDescribeResources(t *testing.T) {
+	instancePlugin := newTestInstancePlugin()
+	p := NewResourcePlugin(func(name plugin_base.Name) (instance.Plugin, error) {
+		return instancePlugin, nil
+	})
+
+	aID, err := instancePlugin.Provision(instance.Spec{Tags: map[string]string{resourcesTag: configID, resourcesIDTag: "a"}})
+	require.NoError(t, err)
+	bID, err := instancePlugin.Provision(instance.Spec{Tags: map[string]string{resourcesTag: configID, resourcesIDTag: "b"}})
+	require.NoError(t, err)
+
+	spec := resource.Spec{
+		ID:         configID,
+		Properties: types.AnyString(resourcesJSON),
+	}
+	details, err := p.DescribeResources(spec)
+	require.NoError(t, err)
+	require.Equal(t, fmt.Sprintf("Found a (%s)\nFound b (%s)", string(*aID), string(*bID)), details)
+}
+
+func TestDescribe(t *testing.T) {
+	instancePlugin := newTestInstancePlugin()
+
+	aID, err := instancePlugin.Provision(instance.Spec{Tags: map[string]string{resourcesTag: configID, resourcesIDTag: "a"}})
+	require.NoError(t, err)
+	bID, err := instancePlugin.Provision(instance.Spec{Tags: map[string]string{resourcesTag: configID, resourcesIDTag: "b"}})
+	require.NoError(t, err)
+	cID, err := instancePlugin.Provision(instance.Spec{Tags: map[string]string{resourcesTag: configID, resourcesIDTag: "c"}})
+	require.NoError(t, err)
+
+	configs := map[string]resourceConfig{
+		"a": {plugin: instancePlugin},
+		"b": {plugin: instancePlugin},
+		"c": {plugin: instancePlugin},
+	}
+	ids, err := describe(configID, configs)
+	require.NoError(t, err)
+	require.Equal(t, map[string]instance.ID{"a": *aID, "b": *bID, "c": *cID}, ids)
+
+	configs = map[string]resourceConfig{
+		"b": {plugin: instancePlugin},
+		"c": {plugin: instancePlugin},
+		"d": {plugin: instancePlugin},
+	}
+	ids, err = describe(configID, configs)
+	require.NoError(t, err)
+	require.Equal(t, map[string]instance.ID{"b": *bID, "c": *cID}, ids)
+
+	ids, err = describe("returns no IDs given a different"+configID, configs)
+	require.NoError(t, err)
+	require.Equal(t, map[string]instance.ID{}, ids)
+
+	// Error from instance.Plugin.DescribeInstances.
+	errorPlugin := &testing_instance.Plugin{
+		DoDescribeInstances: func(tags map[string]string) ([]instance.Description, error) {
+			return nil, errors.New("kaboom")
+		},
+	}
+	configs = map[string]resourceConfig{
+		"a": {plugin: errorPlugin},
+	}
+	_, err = describe(configID, configs)
+	require.Error(t, err)
+
+	// Multiple resources with the same name.
+	instanceSpec := instance.Spec{Tags: map[string]string{resourcesTag: configID, resourcesIDTag: "x"}}
+	_, err = instancePlugin.Provision(instanceSpec)
+	require.NoError(t, err)
+	_, err = instancePlugin.Provision(instanceSpec)
+	require.NoError(t, err)
+	configs = map[string]resourceConfig{
+		"x": {plugin: instancePlugin},
+	}
+	_, err = describe(configID, configs)
+	require.Error(t, err)
+
+}
+
+func TestValidate(t *testing.T) {
+	instancePlugin := &testing_instance.Plugin{
+		DoValidate: func(req *types.Any) error { return nil },
+	}
+	lookup := func(name plugin_base.Name) (instance.Plugin, error) {
+		if name == "p" {
+			return instancePlugin, nil
+		}
+		return nil, errors.New("not found")
+	}
+
+	newResourceDotSpec := func(id, properties string) resource.Spec {
+		var i interface{}
+		if err := json.Unmarshal([]byte(properties), &i); err != nil {
+			panic(err)
+		}
+
+		return resource.Spec{
+			ID:         resource.ID(id),
+			Properties: types.AnyString(properties),
+		}
+	}
+
+	// Missing resource.Spec.ID.
+	_, _, err := validate(newResourceDotSpec("", `{}`), lookup)
+	require.Error(t, err)
+
+	// Missing resource.Spec.Properties.
+	_, _, err = validate(resource.Spec{ID: "id", Properties: nil}, lookup)
+	require.Error(t, err)
+
+	// Malformed resource.Spec.Properties.
+	_, _, err = validate(resource.Spec{ID: "id", Properties: types.AnyString(`malformed JSON`)}, lookup)
+	require.Error(t, err)
+
+	// Missing resource ID.
+	_, _, err = validate(newResourceDotSpec("id", `{"Resources": [{"Plugin": "p", "Properties": ""}]}`), lookup)
+	require.Error(t, err)
+
+	// Missing resource plugin.
+	_, _, err = validate(newResourceDotSpec("id", `{"Resources": [{"ID": "a", "Properties": ""}]}`), lookup)
+	require.Error(t, err)
+
+	// Nonexistent resource plugin.
+	_, _, err = validate(newResourceDotSpec("id", `{"Resources": [{"ID": "a", "Plugin": "nonexistent", "Properties": ""}]}`), lookup)
+	require.Error(t, err)
+
+	// Missing resource properties.
+	_, _, err = validate(newResourceDotSpec("id", `{"Resources": [{"ID": "a", "Plugin": "p"}]}`), lookup)
+	require.Error(t, err)
+
+	// Malformed resource properties.
+	properties := `{"Resources": [{"ID": "a", "Plugin": "p", "Properties": "{{/* malformed template"}]}`
+	_, _, err = validate(newResourceDotSpec("id", properties), lookup)
+	require.Error(t, err)
+
+	configs, provisioningOrder, err := validate(newResourceDotSpec("id", `{}`), lookup)
+	require.NoError(t, err)
+	require.Equal(t, map[string]resourceConfig{}, configs)
+	require.Len(t, provisioningOrder, 0)
+
+	// Empty resource properties.
+	properties = `{"Resources": [{"ID": "a", "Plugin": "p", "Properties": ""}]}`
+	configs, provisioningOrder, err = validate(newResourceDotSpec("id", properties), lookup)
+	require.NoError(t, err)
+	expectedConfigs := map[string]resourceConfig{
+		"a": {plugin: instancePlugin, properties: `""`},
+	}
+	require.Equal(t, expectedConfigs, configs)
+	require.Equal(t, []string{"a"}, provisioningOrder)
+
+	properties = `{"Resources": [{"ID": "a", "Plugin": "p", "Properties": "{{ resource ` + "`b`" + ` }}"}, {"ID": "b", "Plugin": "p", "Properties": ""}]}`
+	configs, provisioningOrder, err = validate(newResourceDotSpec("id", properties), lookup)
+	require.NoError(t, err)
+	expectedConfigs = map[string]resourceConfig{
+		"a": {plugin: instancePlugin, properties: `"{{ resource ` + "`b`" + ` }}"`},
+		"b": {plugin: instancePlugin, properties: `""`},
+	}
+	require.Equal(t, expectedConfigs, configs)
+	require.Equal(t, []string{"b", "a"}, provisioningOrder)
+}
+
+func TestGetProvisioningOrder(t *testing.T) {
+	_, err := getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{/* malformed template }}`},
+	})
+	require.Error(t, err)
+
+	_, err = getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{ wellFormedTemplateWithExecutionError }}`},
+	})
+	require.Error(t, err)
+
+	_, err = getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{ resource "nonexistent" }}`},
+	})
+	require.Error(t, err)
+
+	_, err = getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{ resource "a" }}`},
+	})
+	require.Error(t, err)
+
+	_, err = getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{ resource "b" }}`},
+		"b": {properties: `{{ resource "a" }}`},
+	})
+	require.Error(t, err)
+
+	order, err := getProvisioningOrder(map[string]resourceConfig{})
+	require.NoError(t, err)
+	require.Equal(t, []string{}, order)
+
+	order, err = getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{ resource "b" }}`},
+		"b": {properties: ``},
+	})
+	require.NoError(t, err)
+	require.Equal(t, []string{"b", "a"}, order)
+
+	order, err = getProvisioningOrder(map[string]resourceConfig{
+		"a": {properties: `{{ resource "b" }}`},
+		"b": {properties: `{{ resource "c" }} {{ resource "d" }}`},
+		"c": {properties: `{{ resource "e" }}`},
+		"d": {properties: `{{ resource "e" }}`},
+		"e": {properties: `{{ resource "f" }}`},
+		"f": {properties: ``},
+	})
+	require.NoError(t, err)
+	require.Condition(t, func() bool {
+		return (reflect.DeepEqual(order, []string{"f", "e", "d", "c", "b", "a"}) ||
+			reflect.DeepEqual(order, []string{"f", "e", "c", "d", "b", "a"}))
+
+	})
+}
+
+func TestGetResourceDependencies(t *testing.T) {
+	newTemplate := func(s string) *template.Template {
+		t, err := template.NewTemplate("str://"+s, template.Options{SocketDir: discovery.Dir()})
+		if err != nil {
+			panic(err)
+		}
+		return t
+	}
+
+	_, err := getResourceDependencies(newTemplate(`{{ wellFormedTemplateWithExecutionError }}`))
+	require.Error(t, err)
+
+	deps, err := getResourceDependencies(newTemplate(``))
+	require.NoError(t, err)
+	require.Len(t, deps, 0)
+
+	deps, err = getResourceDependencies(newTemplate(`{{ resource "a" }}`))
+	require.NoError(t, err)
+	require.Equal(t, map[string]bool{"a": true}, deps)
+
+	deps, err = getResourceDependencies(newTemplate(`{{ resource "a" }} {{ resource "a" }}`))
+	require.NoError(t, err)
+	require.Equal(t, map[string]bool{"a": true}, deps)
+
+	deps, err = getResourceDependencies(newTemplate(`{{ resource "a" }} {{ resource "b" }} {{ resource "c" }}`))
+	require.NoError(t, err)
+	require.Equal(t, map[string]bool{"a": true, "b": true, "c": true}, deps)
+}
diff --git a/pkg/rpc/resource/client.go b/pkg/rpc/resource/client.go
new file mode 100644
index 000000000..6ac457c82
--- /dev/null
+++ b/pkg/rpc/resource/client.go
@@ -0,0 +1,54 @@
+package resource
+
+import (
+	rpc_client "github.com/docker/infrakit/pkg/rpc/client"
+	"github.com/docker/infrakit/pkg/spi/resource"
+)
+
+// NewClient returns a plugin interface implementation connected to a remote plugin.
+func NewClient(socketPath string) (resource.Plugin, error) {
+	rpcClient, err := rpc_client.New(socketPath, resource.InterfaceSpec)
+	if err != nil {
+		return nil, err
+	}
+	return Adapt(rpcClient), nil
+}
+
+// Adapt converts an RPC client to a resource plugin.
+func Adapt(rpcClient rpc_client.Client) resource.Plugin {
+	return &client{client: rpcClient}
+}
+
+type client struct {
+	client rpc_client.Client
+}
+
+func (c client) Commit(spec resource.Spec, pretend bool) (string, error) {
+	req := CommitRequest{Spec: spec, Pretend: pretend}
+	resp := CommitResponse{}
+	err := c.client.Call("Resource.Commit", req, &resp)
+	if err != nil {
+		return resp.Details, err
+	}
+	return resp.Details, nil
+}
+
+func (c client) Destroy(spec resource.Spec, pretend bool) (string, error) {
+	req := DestroyRequest{Spec: spec, Pretend: pretend}
+	resp := DestroyResponse{}
+	err := c.client.Call("Resource.Destroy", req, &resp)
+	if err != nil {
+		return resp.Details, err
+	}
+	return resp.Details, nil
+}
+
+func (c client) DescribeResources(spec resource.Spec) (string, error) {
+	req := DescribeResourcesRequest{Spec: spec}
+	resp := DescribeResourcesResponse{}
+	err := c.client.Call("Resource.DescribeResources", req, &resp)
+	if err != nil {
+		return "", err
+	}
+	return resp.Details, nil
+}
diff --git a/pkg/rpc/resource/rpc_test.go b/pkg/rpc/resource/rpc_test.go
new file mode 100644
index 000000000..812659fd8
--- /dev/null
+++ b/pkg/rpc/resource/rpc_test.go
@@ -0,0 +1,185 @@
+package resource
+
+import (
+	"errors"
+	"testing"
+
+	"io/ioutil"
+	"path"
+
+	rpc_server "github.com/docker/infrakit/pkg/rpc/server"
+	"github.com/docker/infrakit/pkg/spi/resource"
+	testing_resource "github.com/docker/infrakit/pkg/testing/resource"
+	"github.com/docker/infrakit/pkg/types"
+	"github.com/stretchr/testify/require"
+)
+
+func must(p resource.Plugin, err error) resource.Plugin {
+	if err != nil {
+		panic(err)
+	}
+	return p
+}
+
+func tempSocket() string {
+	dir, err := ioutil.TempDir("", "infrakit-test-")
+	if err != nil {
+		panic(err)
+	}
+
+	return path.Join(dir, "resource-impl-test")
+}
+
+func TestResourcePluginCommit(t *testing.T) {
+	socketPath := tempSocket()
+
+	resourceSpecActual := make(chan resource.Spec, 1)
+	resourceSpec := resource.Spec{
+		ID:         resource.ID("resource"),
+		Properties: types.AnyString(`{"foo":"bar"}`),
+	}
+
+	server, err := rpc_server.StartPluginAtPath(socketPath, PluginServer(&testing_resource.Plugin{
+		DoCommit: func(req resource.Spec, pretend bool) (string, error) {
+			resourceSpecActual <- req
+			return "details", nil
+		},
+	}))
+
+	details, err := must(NewClient(socketPath)).Commit(resourceSpec, false)
+	require.NoError(t, err)
+	require.Equal(t, "details", details)
+
+	server.Stop()
+
+	require.Equal(t, resourceSpec, <-resourceSpecActual)
+}
+
+func TestResourcePluginCommitError(t *testing.T) {
+	socketPath := tempSocket()
+
+	resourceSpecActual := make(chan resource.Spec, 1)
+	resourceSpec := resource.Spec{
+		ID:         resource.ID("resource"),
+		Properties: types.AnyString(`{"foo":"bar"}`),
+	}
+
+	server, err := rpc_server.StartPluginAtPath(socketPath, PluginServer(&testing_resource.Plugin{
+		DoCommit: func(req resource.Spec, pretend bool) (string, error) {
+			resourceSpecActual <- req
+			return "", errors.New("error")
+		},
+	}))
+	require.NoError(t, err)
+
+	_, err = must(NewClient(socketPath)).Commit(resourceSpec, false)
+	require.Error(t, err)
+	require.Equal(t, "error", err.Error())
+
+	server.Stop()
+
+	require.Equal(t, resourceSpec, <-resourceSpecActual)
+}
+
+func TestResourcePluginDestroy(t *testing.T) {
+	socketPath := tempSocket()
+
+	resourceSpecActual := make(chan resource.Spec, 1)
+	resourceSpec := resource.Spec{
+		ID:         resource.ID("resource"),
+		Properties: types.AnyString(`{"foo":"bar"}`),
+	}
+
+	server, err := rpc_server.StartPluginAtPath(socketPath, PluginServer(&testing_resource.Plugin{
+		DoDestroy: func(req resource.Spec, pretend bool) (string, error) {
+			resourceSpecActual <- req
+			return "details", nil
+		},
+	}))
+
+	details, err := must(NewClient(socketPath)).Destroy(resourceSpec, false)
+	require.NoError(t, err)
+	require.Equal(t, "details", details)
+
+	server.Stop()
+
+	require.Equal(t, resourceSpec, <-resourceSpecActual)
+}
+
+func TestResourcePluginDestroyError(t *testing.T) {
+	socketPath := tempSocket()
+
+	resourceSpecActual := make(chan resource.Spec, 1)
+	resourceSpec := resource.Spec{
+		ID:         resource.ID("resource"),
+		Properties: types.AnyString(`{"foo":"bar"}`),
+	}
+
+	server, err := rpc_server.StartPluginAtPath(socketPath, PluginServer(&testing_resource.Plugin{
+		DoDestroy: func(req resource.Spec, pretend bool) (string, error) {
+			resourceSpecActual <- req
+			return "", errors.New("error")
+		},
+	}))
+	require.NoError(t, err)
+
+	_, err = must(NewClient(socketPath)).Destroy(resourceSpec, false)
+	require.Error(t, err)
+	require.Equal(t, "error", err.Error())
+
+	server.Stop()
+
+	require.Equal(t, resourceSpec, <-resourceSpecActual)
+}
+
+func TestResourcePluginDescribeResources(t *testing.T) {
+	socketPath := tempSocket()
+
+	resourceSpecActual := make(chan resource.Spec, 1)
+	resourceSpec := resource.Spec{
+		ID:         resource.ID("resource"),
+		Properties: types.AnyString(`{"foo":"bar"}`),
+	}
+	details := "details"
+
+	server, err := rpc_server.StartPluginAtPath(socketPath, PluginServer(&testing_resource.Plugin{
+		DoDescribeResources: func(req resource.Spec) (string, error) {
+			resourceSpecActual <- req
+			return details, nil
+		},
+	}))
+
+	detailsActual, err := must(NewClient(socketPath)).DescribeResources(resourceSpec)
+	require.NoError(t, err)
+	require.Equal(t, details, detailsActual)
+
+	server.Stop()
+
+	require.Equal(t, resourceSpec, <-resourceSpecActual)
+}
+
+func TestResourcePluginDescribeResourcesError(t *testing.T) {
+	socketPath := tempSocket()
+
+	resourceSpecActual := make(chan resource.Spec, 1)
+	resourceSpec := resource.Spec{
+		ID:         resource.ID("resource"),
+		Properties: types.AnyString(`{"foo":"bar"}`),
+	}
+
+	server, err := rpc_server.StartPluginAtPath(socketPath, PluginServer(&testing_resource.Plugin{
+		DoDescribeResources: func(req resource.Spec) (string, error) {
+			resourceSpecActual <- req
+			return "", errors.New("error")
+		},
+	}))
+	require.NoError(t, err)
+
+	_, err = must(NewClient(socketPath)).DescribeResources(resourceSpec)
+	require.Error(t, err)
+	require.Equal(t, "error", err.Error())
+
+	server.Stop()
+
+	require.Equal(t, resourceSpec, <-resourceSpecActual)
+}
diff --git a/pkg/rpc/resource/service.go b/pkg/rpc/resource/service.go
new file mode 100644
index 000000000..2e0116950
--- /dev/null
+++ b/pkg/rpc/resource/service.go
@@ -0,0 +1,71 @@
+package resource
+
+import (
+	"net/http"
+
+	"github.com/docker/infrakit/pkg/spi"
+	"github.com/docker/infrakit/pkg/spi/resource"
+	"github.com/docker/infrakit/pkg/types"
+)
+
+// PluginServer returns an RPCService that conforms to the net/rpc calling convention.
+func PluginServer(p resource.Plugin) *Resource {
+	return &Resource{plugin: p}
+}
+
+// Resource is the exported type needed to conform to the json-rpc calling convention.
+type Resource struct {
+	plugin resource.Plugin
+}
+
+// VendorInfo returns a metadata object about the plugin, if the plugin implements it.  See plugin.Vendor.
+func (p *Resource) VendorInfo() *spi.VendorInfo {
+	if m, is := p.plugin.(spi.Vendor); is {
+		return m.VendorInfo()
+	}
+	return nil
+}
+
+// ExampleProperties returns an example properties used by the plugin.
+func (p *Resource) ExampleProperties() *types.Any {
+	if i, is := p.plugin.(spi.InputExample); is {
+		return i.ExampleProperties()
+	}
+	return nil
+}
+
+// ImplementedInterface returns the interface implemented by this RPC service.
+func (p *Resource) ImplementedInterface() spi.InterfaceSpec {
+	return resource.InterfaceSpec
+
+}
+
+// Commit is the rpc method to commit resources.
+func (p *Resource) Commit(_ *http.Request, req *CommitRequest, resp *CommitResponse) error {
+	details, err := p.plugin.Commit(req.Spec, req.Pretend)
+	if err != nil {
+		return err
+	}
+	resp.Details = details
+	return nil
+}
+
+// Destroy is the rpc method to destroy resources.
+func (p *Resource) Destroy(_ *http.Request, req *DestroyRequest, resp *DestroyResponse) error {
+	details, err := p.plugin.Destroy(req.Spec, req.Pretend)
+	if err != nil {
+		return err
+	}
+	resp.Details = details
+	return nil
+}
+
+// DescribeResources is the rpc method to describe a resource.
+func (p *Resource) DescribeResources(_ *http.Request, req *DescribeResourcesRequest, resp *DescribeResourcesResponse) error {
+	details, err := p.plugin.DescribeResources(req.Spec)
+	if err != nil {
+		return err
+	}
+	resp.Details = details
+	return nil
+}
diff --git a/pkg/rpc/resource/types.go b/pkg/rpc/resource/types.go
new file mode 100644
index 000000000..10fa603f7
--- /dev/null
+++ b/pkg/rpc/resource/types.go
@@ -0,0 +1,35 @@
+package resource
+
+import "github.com/docker/infrakit/pkg/spi/resource"
+
+// CommitRequest is the RPC wrapper for the Commit request.
+type CommitRequest struct {
+	Spec    resource.Spec
+	Pretend bool
+}
+
+// CommitResponse is the RPC wrapper for the Commit response.
+type CommitResponse struct {
+	Details string
+}
+
+// DestroyRequest is the RPC wrapper for the Destroy request.
+type DestroyRequest struct {
+	Spec    resource.Spec
+	Pretend bool
+}
+
+// DestroyResponse is the RPC wrapper for the Destroy response.
+type DestroyResponse struct {
+	Details string
+}
+
+// DescribeResourcesRequest is the RPC wrapper for the DescribeResources request.
+type DescribeResourcesRequest struct {
+	Spec resource.Spec
+}
+
+// DescribeResourcesResponse is the RPC wrapper for the DescribeResources response.
+type DescribeResourcesResponse struct {
+	Details string
+}
diff --git a/pkg/spi/resource/spi.go b/pkg/spi/resource/spi.go
new file mode 100644
index 000000000..0f2226832
--- /dev/null
+++ b/pkg/spi/resource/spi.go
@@ -0,0 +1,32 @@
+package resource
+
+import (
+	"github.com/docker/infrakit/pkg/spi"
+	"github.com/docker/infrakit/pkg/types"
+)
+
+// InterfaceSpec is the current name and version of the Resource API.
+var InterfaceSpec = spi.InterfaceSpec{
+	Name:    "Resource",
+	Version: "0.1.0",
+}
+
+// ID is the unique identifier for a collection of resources.
+type ID string
+
+// Spec is a specification of resources to provision.
+type Spec struct {
+
+	// ID is the unique identifier for the collection of resources.
+	ID ID
+
+	// Properties is the opaque configuration for the resources.
+	Properties *types.Any
+}
+
+// Plugin defines the functions for a Resource plugin.
+type Plugin interface {
+	Commit(spec Spec, pretend bool) (string, error)
+	Destroy(spec Spec, pretend bool) (string, error)
+	DescribeResources(spec Spec) (string, error)
+}
diff --git a/pkg/testing/resource/plugin.go b/pkg/testing/resource/plugin.go
new file mode 100644
index 000000000..50618a3e5
--- /dev/null
+++ b/pkg/testing/resource/plugin.go
@@ -0,0 +1,31 @@
+package resource
+
+import "github.com/docker/infrakit/pkg/spi/resource"
+
+// Plugin implements resource.Plugin.
+type Plugin struct {
+
+	// DoCommit implements Commit.
+	DoCommit func(spec resource.Spec, pretend bool) (string, error)
+
+	// DoDestroy implements Destroy.
+	DoDestroy func(spec resource.Spec, pretend bool) (string, error)
+
+	// DoDescribeResources implements DescribeResources.
+	DoDescribeResources func(spec resource.Spec) (string, error)
+}
+
+// Commit creates the resources in the spec that do not exist.
+func (t *Plugin) Commit(spec resource.Spec, pretend bool) (string, error) {
+	return t.DoCommit(spec, pretend)
+}
+
+// Destroy destroys all resources in the spec.
+func (t *Plugin) Destroy(spec resource.Spec, pretend bool) (string, error) {
+	return t.DoDestroy(spec, pretend)
+}
+
+// DescribeResources describes the resources in the spec that exist.
+func (t *Plugin) DescribeResources(spec resource.Spec) (string, error) {
+	return t.DoDescribeResources(spec)
+}
diff --git a/vendor.conf b/vendor.conf
index 71c7aed4b..1eca6d077 100644
--- a/vendor.conf
+++ b/vendor.conf
@@ -62,6 +62,7 @@ github.com/spf13/afero                                  06b7e5f
 github.com/spf13/cobra                                  6e91dde
 github.com/spf13/pflag                                  5ccb023
 github.com/stretchr/testify                             v1.1.4-4-g976c720
+github.com/twmb/algoimpl                                716f8e7
 golang.org/x/crypto/pbkdf2                              b07d8c9
 golang.org/x/net                                        0dd7c8d
 golang.org/x/sys                                        b699b70
@@ -76,4 +77,4 @@ gopkg.in/juju/names.v2                                  0847c26
 gopkg.in/mgo.v2/bson                                    3f83fa5
 gopkg.in/mgo.v2/internal                                3f83fa5
 gopkg.in/tylerb/graceful.v1                             v1.2.13
-gopkg.in/yaml.v2                                        a5b47d3
\ No newline at end of file
+gopkg.in/yaml.v2                                        a5b47d3
diff --git a/vendor/github.com/twmb/algoimpl/.gitignore b/vendor/github.com/twmb/algoimpl/.gitignore
new file mode 100644
index 000000000..66fc796a2
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/.gitignore
@@ -0,0 +1,7 @@
+*.sw[a-z]
+.metadata
+.classpath
+.project
+.settings
+bin/
+
diff --git a/vendor/github.com/twmb/algoimpl/LICENSE b/vendor/github.com/twmb/algoimpl/LICENSE
new file mode 100644
index 000000000..f59423c58
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/LICENSE
@@ -0,0 +1,24 @@
+Copyright (c) 2013 Travis Bischel. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/twmb/algoimpl/README.md b/vendor/github.com/twmb/algoimpl/README.md
new file mode 100644
index 000000000..d9aff657c
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/README.md
@@ -0,0 +1,8 @@
+# Algoimpl
+
+A collection of various algorithms in various languages. I have tried
+to organize them into appropriate directories in case anybody wants to
+import a package in to their library.
+
+My go [graph](http://godoc.org/github.com/twmb/algoimpl/go/graph) package
+is well built. Use it. Give me suggestions.
diff --git a/vendor/github.com/twmb/algoimpl/go/graph/functions.go b/vendor/github.com/twmb/algoimpl/go/graph/functions.go
new file mode 100644
index 000000000..e5e1f31f8
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/go/graph/functions.go
@@ -0,0 +1,346 @@
+package graph
+
+import (
+	"errors"
+	"github.com/twmb/algoimpl/go/graph/lite"
+	"math/rand"
+	"sort"
+	"sync"
+)
+
+const (
+	dequeued = ^(1<<31 - 1)
+	unseen   = 0
+	seen     = 1
+)
+
+// O(V + E). It does not matter to traverse back
+// on a bidirectional edge, because any vertex dfs is
+// recursing on is marked as visited and won't be visited
+// again anyway.
+func (g *Graph) dfs(node *node, finishList *[]Node) {
+	node.state = seen
+	for _, edge := range node.edges {
+		if edge.end.state == unseen {
+			edge.end.parent = node
+			g.dfs(edge.end, finishList)
+		}
+	}
+	*finishList = append(*finishList, node.container)
+}
+
+func (g *Graph) dfsReversedEdges(node *node, finishList *[]Node) {
+	node.state = seen
+	for _, edge := range node.reversedEdges {
+		if edge.end.state == unseen {
+			edge.end.parent = node
+			g.dfsReversedEdges(edge.end, finishList)
+		}
+	}
+	*finishList = append(*finishList, node.container)
+}
+
+func (g *Graph) bfs(n *node, finishList *[]Node) {
+	queue := make([]*node, 0, len(n.edges))
+	queue = append(queue, n)
+	for i := 0; i < len(queue); i++ {
+		node := queue[i]
+		node.state = seen
+		for _, edge := range node.edges {
+			if edge.end.state == unseen {
+				edge.end.state = seen
+				queue = append(queue, edge.end)
+			}
+		}
+	}
+	*finishList = make([]Node, 0, len(queue))
+	for i := range queue {
+		*finishList = append(*finishList, queue[i].container)
+	}
+}
+
+// TopologicalSort topoligically sorts a directed acyclic graph.
+// If the graph is cyclic, the sort order will change
+// based on which node the sort starts on.
+//
+// The StronglyConnectedComponents function can be used to determine if a graph has cycles.
+func (g *Graph) TopologicalSort() []Node {
+	if g.Kind == Undirected {
+		return nil
+	}
+	// init states
+	for i := range g.nodes {
+		g.nodes[i].state = unseen
+	}
+	sorted := make([]Node, 0, len(g.nodes))
+	// sort preorder (first jacket, then shirt)
+	for _, node := range g.nodes {
+		if node.state == unseen {
+			g.dfs(node, &sorted)
+		}
+	}
+	// now make post order for correct sort (jacket follows shirt). O(V)
+	length := len(sorted)
+	for i := 0; i < length/2; i++ {
+		sorted[i], sorted[length-i-1] = sorted[length-i-1], sorted[i]
+	}
+	return sorted
+}
+
+// Reverse returns reversed copy of the directed graph g.
+// This function can be used to copy an undirected graph.
+func (g *Graph) Reverse() *Graph {
+	reversed := New(Directed)
+	if g.Kind == Undirected {
+		reversed = New(Undirected)
+	}
+	// O(V)
+	for _ = range g.nodes {
+		reversed.MakeNode()
+	}
+	// O(V + E)
+	for _, node := range g.nodes {
+		for _, edge := range node.edges {
+			reversed.MakeEdge(reversed.nodes[edge.end.index].container,
+				reversed.nodes[node.index].container)
+		}
+	}
+	return reversed
+}
+
+// StronglyConnectedComponents returns a slice of strongly connected nodes in a directed graph.
+// If used on an undirected graph, this function returns distinct connected components.
+func (g *Graph) StronglyConnectedComponents() [][]Node {
+	if g.Kind == Undirected {
+		return g.sccUndirected()
+	}
+	return g.sccDirected()
+}
+
+// the connected components algorithm for an undirected graph
+func (g *Graph) sccUndirected() [][]Node {
+	components := make([][]Node, 0)
+	for _, node := range g.nodes {
+		if node.state == unseen {
+			component := make([]Node, 0)
+			g.bfs(node, &component)
+			components = append(components, component)
+		}
+	}
+	return components
+}
+
+// the Strongly Connected Components algorithm for a directed graph
+func (g *Graph) sccDirected() [][]Node {
+	components := make([][]Node, 0)
+	finishOrder := g.TopologicalSort()
+	for i := range finishOrder {
+		finishOrder[i].node.state = unseen
+	}
+	for _, sink := range finishOrder {
+		if g.nodes[sink.node.index].state == unseen {
+			component := make([]Node, 0)
+			g.dfsReversedEdges(g.nodes[sink.node.index], &component)
+			components = append(components, component)
+		}
+	}
+	return components
+}
+
+// RandMinimumCut runs Kargers algorithm to find a random minimum cut
+// on the graph. If iterations is < 1, this will return an empty slice.
+// Otherwise, it returns a slice of the edges crossing the best minimum
+// cut found in any iteration. Call rand.Seed() before using this function.
+//
+// This function takes a number of iterations to start concurrently. If
+// concurrent is <= 1, it will run one iteration at a time.
+//
+// If the graph is Directed, this will return a cut of edges in both directions.
+// If the graph is Undirected, this will return a proper min cut.
+func (g *Graph) RandMinimumCut(iterations, concurrent int) []Edge {
+	var mutex sync.Mutex
+	doneChan := make(chan struct{}, iterations)
+	if concurrent < 1 {
+		concurrent = 1
+	}
+	sem := make(chan struct{}, concurrent)
+	for i := 0; i < concurrent; i++ {
+		sem <- struct{}{}
+	}
+	// make a lite slice of the edges
+	var baseAllEdges []lite.Edge
+	for n := range g.nodes {
+		for _, edge := range g.nodes[n].edges {
+			if g.Kind == Undirected && n < edge.end.index {
+				continue
+			}
+			baseAllEdges = append(baseAllEdges, lite.Edge{Start: n,
+				End: edge.end.index, S: g.nodes[n], E: edge})
+		}
+	}
+
+	minCutLite := make([]lite.Edge, len(baseAllEdges))
+
+	for iter := 0; iter < iterations; iter++ {
+		<-sem
+		go func() {
+			nodecount := len(g.nodes)
+			allEdges := make([]lite.Edge, len(baseAllEdges))
+			copy(allEdges, baseAllEdges)
+			// shuffle for random edge removal order
+			shuffle(allEdges)
+			for nodecount > 2 {
+				// remove first edge, keep the start node, collapse the end node
+				// anything that points to the collapsing node now points to the keep node
+				// anything that starts at the collapsing node now starts at the keep node
+				keep := allEdges[len(allEdges)-1].Start
+				remove := allEdges[len(allEdges)-1].End
+				allEdges = allEdges[:len(allEdges)-1]
+				for e := 0; e < len(allEdges); e++ {
+					if allEdges[e].Start == remove {
+						allEdges[e].Start = keep
+					}
+					if allEdges[e].End == remove {
+						allEdges[e].End = keep
+					}
+					// remove the edge if it self looped
+					if allEdges[e].Start == allEdges[e].End {
+						allEdges[e] = allEdges[len(allEdges)-1]
+						allEdges = allEdges[:len(allEdges)-1]
+						e--
+					}
+				}
+				// every edge removed removes a node
+				nodecount--
+			}
+
+			mutex.Lock()
+			if iter == 0 || len(allEdges) < len(minCutLite) {
+				minCutLite = make([]lite.Edge, len(allEdges))
+				copy(minCutLite, allEdges)
+			}
+			mutex.Unlock()
+
+			doneChan <- struct{}{}
+			sem <- struct{}{}
+		}()
+	}
+	for iter := 0; iter < iterations; iter++ {
+		<-doneChan
+	}
+
+	minCut := make([]Edge, len(minCutLite))
+	for i := range minCutLite {
+		start := minCutLite[i].S.(*node)
+		edge := minCutLite[i].E.(edge)
+		minCut[i] = Edge{Weight: edge.weight, Start: start.container,
+			End: edge.end.container}
+	}
+	return minCut
+}
+
+// Fischer-Yates shuffle
+func shuffle(edges []lite.Edge) {
+	for i := len(edges) - 1; i > 0; i-- {
+		j := rand.Intn(i + 1)
+		edges[j], edges[i] = edges[i], edges[j]
+	}
+}
+
+// MinimumSpanningTree will return the edges corresponding to the
+// minimum spanning tree in the graph based off of edge weight values.
+// This will return nil for a directed graph.
+func (g *Graph) MinimumSpanningTree() []Edge {
+	if g.Kind == Directed {
+		return nil
+	}
+	// create priority queue for vertices
+	// node.data is the index into the heap
+	// node.state is the weight of an edge to its parent
+	nodesBase := nodeSlice(make([]*node, len(g.nodes)))
+	copy(nodesBase, g.nodes)
+	for i := range nodesBase {
+		nodesBase[i].state = 1<<31 - 1
+		nodesBase[i].data = i
+	}
+	nodesBase[0].state = 0
+	nodesBase[0].parent = nil
+	nodes := &nodesBase
+	nodes.heapInit()
+
+	for len(*nodes) > 0 {
+		min := nodes.pop()
+		for _, edge := range min.edges {
+			v := edge.end // get the other side of the edge
+			if nodes.heapContains(v) && edge.weight < v.state {
+				v.parent = min
+				nodes.update(v.data, edge.weight)
+			}
+		}
+	}
+
+	mst := make([]Edge, 0, len(g.nodes)-1)
+	for _, node := range g.nodes {
+		if node.parent != nil {
+			mst = append(mst, Edge{Weight: node.state,
+				Start: node.container, End: node.parent.container})
+		} else {
+			node.data = 0
+		}
+	}
+
+	return mst
+}
+
+// MaxSpacingClustering returns a slice of clusters
+// with the distance between the clusters maximized as
+// well as the maximized distance between these clusters.
+// It takes as input the number of clusters to compute.
+func (g *Graph) MaxSpacingClustering(n int) ([][]Node, int, error) {
+	if n < 1 || n > len(g.nodes) {
+		return nil, 0, errors.New("MaxSpacingClustering: invalid number of clusters requested")
+	}
+	mst := g.MinimumSpanningTree()
+	sort.Sort(sort.Reverse(edgeSlice(mst)))
+	distance := 0
+
+	// node.data is a cluster it belongs to
+	for i := 0; i < n-1; i++ {
+		// Use the start node: to 'remove' an edge and set
+		// a leader node to belong to a cluster, start of the edge's parent.
+		// The only node that will have a nil parent is an end node from MST above.
+		// This node already automatically belongs to cluster 0.
+		mst[i].Start.node.parent = nil
+		mst[i].Start.node.data = i + 1
+		distance = mst[i].Weight
+	}
+
+	clusters := make([][]Node, n)
+	for _, node := range g.nodes {
+		c := determineCluster(node)
+		clusters[c] = append(clusters[c], node.container)
+	}
+	return clusters, distance, nil
+}
+
+func determineCluster(n *node) int {
+	// all nodes .data member is set to the dequeued const from MST's .pop().
+	// I use the .data member in clustering as the cluster number.
+	// Thus, if .data == dequeued, then the cluster has not been set yet.
+	if n.data == dequeued {
+		n.data = determineCluster(n.parent)
+	}
+	return n.data
+}
+
+type edgeSlice []Edge
+
+func (e edgeSlice) Len() int {
+	return len(e)
+}
+func (e edgeSlice) Swap(i, j int) {
+	e[i], e[j] = e[j], e[i]
+}
+func (e edgeSlice) Less(i, j int) bool {
+	return e[i].Weight < e[j].Weight
+}
diff --git a/vendor/github.com/twmb/algoimpl/go/graph/graph.go b/vendor/github.com/twmb/algoimpl/go/graph/graph.go
new file mode 100644
index 000000000..0cfd5b560
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/go/graph/graph.go
@@ -0,0 +1,224 @@
+// Implements an adjacency list graph as a slice of generic nodes
+// and includes some useful graph functions.
+package graph
+
+import (
+	"errors"
+)
+
+// Directed or undirected.
+type GraphType int
+
+const (
+	Undirected GraphType = iota
+	Directed
+)
+
+// Graph is an adjacency slice representation of a graph. Can be directed or undirected.
+type Graph struct {
+	nodes []*node
+	Kind  GraphType
+}
+
+type node struct {
+	edges         []edge
+	reversedEdges []edge
+	index         int
+	state         int   // used for metadata
+	data          int   // also used for metadata
+	parent        *node // also used for metadata
+	container     Node  // who holds me
+}
+
+// Node connects to a backing node on the graph. It can safely be used in maps.
+type Node struct {
+	// In an effort to prevent access to the actual graph
+	// and so that the Node type can be used in a map while
+	// the graph changes metadata, the Node type encapsulates
+	// a pointer to the actual node data.
+	node *node
+	// Value can be used to store information on the caller side.
+	// Its use is optional. See the Topological Sort example for
+	// a reason on why to use this pointer.
+	// The reason it is a pointer is so that graph function calls
+	// can test for equality on Nodes. The pointer wont change,
+	// the value it points to will. If the pointer is explicitly changed,
+	// graph functions that use Nodes will cease to work.
+	Value *interface{}
+}
+
+type edge struct {
+	weight int
+	end    *node
+}
+
+// An Edge connects two Nodes in a graph. To modify Weight, use
+// the MakeEdgeWeight function. Any local modifications will
+// not be seen in the graph.
+type Edge struct {
+	Weight int
+	Start  Node
+	End    Node
+}
+
+// New creates and returns an empty graph.
+// If kind is Directed, returns a directed graph.
+// This function returns an undirected graph by default.
+func New(kind GraphType) *Graph {
+	g := &Graph{}
+	if kind == Directed {
+		g.Kind = Directed
+	}
+	return g
+}
+
+// MakeNode creates a node, adds it to the graph and returns the new node.
+func (g *Graph) MakeNode() Node {
+	newNode := &node{index: len(g.nodes)}
+	newNode.container = Node{node: newNode, Value: new(interface{})}
+	g.nodes = append(g.nodes, newNode)
+	return newNode.container
+}
+
+// RemoveNode removes a node from the graph and all edges connected to it.
+// This function nils points in the Node structure. If 'remove' is used in
+// a map, you must delete the map index first.
+func (g *Graph) RemoveNode(remove *Node) {
+	if remove.node == nil {
+		return
+	}
+	// O(V)
+	nodeExists := false
+	// remove all edges that connect from a different node to this one
+	for _, node := range g.nodes {
+		if node == remove.node {
+			nodeExists = true
+			continue
+		}
+
+		// O(E)
+		swapIndex := -1 // index that the edge-to-remove is at
+		for i := range node.edges {
+			if node.edges[i].end == remove.node {
+				swapIndex = i
+			}
+		}
+		if swapIndex > -1 {
+			swapNRemoveEdge(swapIndex, &node.edges)
+		}
+
+		// deal with possible reversed edge
+		swapIndex = -1
+		for i := range node.reversedEdges {
+			if node.reversedEdges[i].end == remove.node {
+				swapIndex = i
+			}
+		}
+		if swapIndex > -1 {
+			swapNRemoveEdge(swapIndex, &node.reversedEdges)
+		}
+		if node.index > remove.node.index {
+			node.index--
+		}
+	}
+	if nodeExists {
+		copy(g.nodes[remove.node.index:], g.nodes[remove.node.index+1:])
+		g.nodes = g.nodes[:len(g.nodes)-1]
+	}
+	remove.node.parent = nil
+	remove.node = nil
+}
+
+// MakeEdge calls MakeEdgeWeight with a weight of 0 and returns an error if either of the nodes do not
+// belong in the graph. Calling MakeEdge multiple times on the same nodes will not create multiple edges.
+func (g *Graph) MakeEdge(from, to Node) error {
+	return g.MakeEdgeWeight(from, to, 0)
+}
+
+// MakeEdgeWeight creates  an edge in the graph with a corresponding weight.
+// It returns an error if either of the nodes do not belong in the graph.
+//
+// Calling MakeEdgeWeight multiple times on the same nodes will not create multiple edges;
+// this function will update the weight on the node to the new value.
+func (g *Graph) MakeEdgeWeight(from, to Node, weight int) error {
+	if from.node == nil || from.node.index >= len(g.nodes) || g.nodes[from.node.index] != from.node {
+		return errors.New("First node in MakeEdge call does not belong to this graph")
+	}
+	if to.node == nil || to.node.index >= len(g.nodes) || g.nodes[to.node.index] != to.node {
+		return errors.New("Second node in MakeEdge call does not belong to this graph")
+	}
+
+	for i := range from.node.edges { // check if edge already exists
+		if from.node.edges[i].end == to.node {
+			from.node.edges[i].weight = weight
+
+			// If the graph is undirected, fix the to node's weight as well
+			if g.Kind == Undirected && to != from {
+				for j := range to.node.edges {
+					if to.node.edges[j].end == from.node {
+						to.node.edges[j].weight = weight
+					}
+				}
+			}
+			return nil
+		}
+	}
+	newEdge := edge{weight: weight, end: to.node}
+	from.node.edges = append(from.node.edges, newEdge)
+	reversedEdge := edge{weight: weight, end: from.node} // weight for undirected graph only
+	if g.Kind == Directed {                              // reversed edges are only used in directed graph algorithms
+		to.node.reversedEdges = append(to.node.reversedEdges, reversedEdge)
+	}
+	if g.Kind == Undirected && to != from {
+		to.node.edges = append(to.node.edges, reversedEdge)
+	}
+	return nil
+}
+
+// RemoveEdge removes edges starting at the from node and ending at the to node.
+// If the graph is undirected, RemoveEdge will remove all edges between the nodes.
+func (g *Graph) RemoveEdge(from, to Node) {
+	fromEdges := from.node.edges
+	toEdges := to.node.edges
+	toReversedEdges := to.node.reversedEdges
+	for e := range fromEdges { // fix from->to
+		if fromEdges[e].end == to.node {
+			swapNRemoveEdge(e, &fromEdges)
+			from.node.edges = fromEdges
+			break
+		}
+	}
+	for e := range toReversedEdges { // fix reversed edges to->from
+		if toReversedEdges[e].end == from.node {
+			swapNRemoveEdge(e, &toReversedEdges)
+			to.node.reversedEdges = toReversedEdges
+			break
+		}
+	}
+	if g.Kind == Undirected && from.node != to.node {
+		for e := range toEdges {
+			if toEdges[e].end == from.node {
+				swapNRemoveEdge(e, &toEdges)
+				to.node.edges = toEdges
+				break
+			}
+		}
+	}
+}
+
+// Neighbors returns a slice of nodes that are reachable from the given node in a graph.
+func (g *Graph) Neighbors(n Node) []Node {
+	neighbors := make([]Node, 0, len(n.node.edges))
+	if g.nodes[n.node.index] == n.node {
+		for _, edge := range n.node.edges {
+			neighbors = append(neighbors, edge.end.container)
+		}
+	}
+	return neighbors
+}
+
+// Swaps an edge to the end of the edges slice and 'removes' it by reslicing.
+func swapNRemoveEdge(remove int, edges *[]edge) {
+	(*edges)[remove], (*edges)[len(*edges)-1] = (*edges)[len(*edges)-1], (*edges)[remove]
+	*edges = (*edges)[:len(*edges)-1]
+}
diff --git a/vendor/github.com/twmb/algoimpl/go/graph/graph_heap.go b/vendor/github.com/twmb/algoimpl/go/graph/graph_heap.go
new file mode 100644
index 000000000..14b246b5c
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/go/graph/graph_heap.go
@@ -0,0 +1,95 @@
+package graph
+
+// Not that I'm falling prey to NIH syndrome, but implementing my own
+// heap will speed up MST and Search algorithms because...
+//
+// Although asserting is relatively cheap, I also need update methods
+// and can save time with an explicit update function.
+// For reference, with one set of data:
+//  - using containers/heap took 425 microseconds,
+//  - switching to my own version of heap took 330 microseconds average,
+//  - adding an update function takes 255 microseconds average.
+// So this was worth it.
+
+type nodeSlice []*node
+
+func (n nodeSlice) less(i, j int) bool {
+	return n[i].state < n[j].state
+}
+func (n nodeSlice) swap(i, j int) {
+	n[j].data, n[i].data = n[i].data, n[j].data // swap data containing indices
+	n[j], n[i] = n[i], n[j]
+}
+
+func (n nodeSlice) shuffleUp(index int) {
+	for {
+		parent := (index - 1) / 2
+		if parent == index || n.less(parent, index) {
+			break
+		}
+		n.swap(parent, index)
+		index = parent
+	}
+}
+
+func (n nodeSlice) shuffleDown(elem, to int) {
+	for {
+		minchild := elem*2 + 1 // left child: elem * 2 + 1
+		if minchild >= to {
+			return
+		}
+		rchild := minchild + 1 // left child + 1
+		if rchild < to && n.less(rchild, minchild) {
+			minchild = rchild
+		}
+		if !n.less(minchild, elem) {
+			return
+		}
+		n.swap(minchild, elem)
+		elem = minchild
+	}
+}
+
+func (n nodeSlice) heapInit() {
+	length := len(n)
+	for i := length/2 - 1; i >= 0; i-- {
+		n.shuffleDown(i, length)
+	}
+}
+
+func (p *nodeSlice) remove(index int) *node {
+	n := *p
+	length := len(n) - 1
+	if length != index {
+		n.swap(length, index)
+		n.shuffleDown(index, length)
+		n.shuffleUp(index)
+	}
+	popped := n[length]
+	popped.data = dequeued
+	n = n[0:length]
+	*p = n
+	return popped
+}
+
+// I don't need shuffleDown call because all updates update to a
+// smaller state (for now)
+func (n nodeSlice) update(index, newState int) {
+	n[index].state = newState
+	n.shuffleUp(index)
+}
+
+func (p *nodeSlice) push(x *node) {
+	n := *p
+	x.data = len(n) // index into heap
+	n = append(n, x)
+	n.shuffleUp(len(n) - 1)
+	*p = n
+}
+
+func (p *nodeSlice) pop() *node {
+	return p.remove(0)
+}
+func (n nodeSlice) heapContains(node *node) bool { // extend heap interface
+	return node.data > dequeued
+}
diff --git a/vendor/github.com/twmb/algoimpl/go/graph/lite/litegraph.go b/vendor/github.com/twmb/algoimpl/go/graph/lite/litegraph.go
new file mode 100644
index 000000000..960343cb2
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/go/graph/lite/litegraph.go
@@ -0,0 +1,18 @@
+package lite
+
+type Graph []Node
+
+type Node struct {
+	Edges []Edge
+}
+type Edge struct {
+	Start, End int
+	S, E       interface{}
+}
+
+func NewGraph(size int) Graph {
+	if size < 0 {
+		return Graph(make([]Node, 0))
+	}
+	return Graph(make([]Node, size))
+}
diff --git a/vendor/github.com/twmb/algoimpl/go/graph/search.go b/vendor/github.com/twmb/algoimpl/go/graph/search.go
new file mode 100644
index 000000000..dfee24cc8
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/go/graph/search.go
@@ -0,0 +1,54 @@
+package graph
+
+type Path struct {
+	Weight int
+	Path   []Edge
+}
+
+// DijkstraSearch returns the shortest path from the start node to every other
+// node in the graph. All edges must have a positive weight, otherwise this
+// function will return nil.
+func (g *Graph) DijkstraSearch(start Node) []Path {
+	if start.node == nil || g.nodes[start.node.index] != start.node {
+		return nil
+	}
+	paths := make([]Path, len(g.nodes))
+
+	nodesBase := nodeSlice(make([]*node, len(g.nodes)))
+	copy(nodesBase, g.nodes)
+	for i := range nodesBase {
+		nodesBase[i].state = 1<<31 - 1
+		nodesBase[i].data = i
+	}
+	start.node.state = 0 // make it so 'start' sorts to the top of the heap
+	nodes := &nodesBase
+	nodes.heapInit()
+
+	for len(*nodes) > 0 {
+		curNode := nodes.pop()
+		for _, edge := range curNode.edges {
+			newWeight := curNode.state + edge.weight
+			if newWeight < curNode.state { // negative edge length
+				return nil
+			}
+			v := edge.end
+			if nodes.heapContains(v) && newWeight < v.state {
+				v.parent = curNode
+				nodes.update(v.data, newWeight)
+			}
+		}
+
+		// build path to this node
+		if curNode.parent != nil {
+			newPath := Path{Weight: curNode.state}
+			newPath.Path = make([]Edge, len(paths[curNode.parent.index].Path)+1)
+			copy(newPath.Path, paths[curNode.parent.index].Path)
+			newPath.Path[len(newPath.Path)-1] = Edge{Weight: curNode.state - curNode.parent.state,
+				Start: curNode.parent.container, End: curNode.container}
+			paths[curNode.index] = newPath
+		} else {
+			paths[curNode.index] = Path{Weight: curNode.state, Path: []Edge{}}
+		}
+	}
+	return paths
+}
diff --git a/vendor/github.com/twmb/algoimpl/go/graph/todo.md b/vendor/github.com/twmb/algoimpl/go/graph/todo.md
new file mode 100644
index 000000000..780264767
--- /dev/null
+++ b/vendor/github.com/twmb/algoimpl/go/graph/todo.md
@@ -0,0 +1,8 @@
+TODO
+----
+~~1) make mincut work on one large slice of shuffled edges (remove litegraph)~~
+~~2) add tests for reverseEdge consistency~~
+~~3) Write Dijkstras algorithm~~
+4) Write tests for Dijkstras algorithm
+5) change ints to int64s ?
+6) do MST eager implementation: http://algs4.cs.princeton.edu/43mst/