diff --git a/lib/OpenLayers.js b/lib/OpenLayers.js
index b0ad334e22..21864c7148 100644
--- a/lib/OpenLayers.js
+++ b/lib/OpenLayers.js
@@ -180,6 +180,8 @@
             "OpenLayers/Renderer/SVG.js",
             "OpenLayers/Renderer/VML.js",
             "OpenLayers/Layer/Vector.js",
+            "OpenLayers/Strategy.js",
+            "OpenLayers/Protocol.js",
             "OpenLayers/Layer/PointTrack.js",
             "OpenLayers/Layer/GML.js",
             "OpenLayers/Style.js",
diff --git a/lib/OpenLayers/Layer/Vector.js b/lib/OpenLayers/Layer/Vector.js
index be62a5576f..565568e53d 100644
--- a/lib/OpenLayers/Layer/Vector.js
+++ b/lib/OpenLayers/Layer/Vector.js
@@ -125,7 +125,19 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
      * {<OpenLayers.StyleMap>}
      */
     styleMap: null,
-
+    
+    /**
+     * Property: strategies
+     * {Array(<OpenLayers.Strategy>})} Optional list of strategies for the layer.
+     */
+    strategies: null,
+    
+    /**
+     * Property: protocol
+     * {<OpenLayers.Protocol>} Optional protocol for the layer.
+     */
+    protocol: null,
+    
     /**
      * Property: renderers
      * {Array(String)} List of supported Renderer classes. Add to this list to
@@ -194,6 +206,14 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
 
         this.features = [];
         this.selectedFeatures = [];
+        
+        // Allow for custom layer behavior
+        if(this.strategies){
+            for(var i=0, len=this.strategies.length; i<len; i++) {
+                this.strategies[i].setLayer(this);
+            }
+        }
+
     },
 
     /**
@@ -201,6 +221,16 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
      * Destroy this layer
      */
     destroy: function() {
+        if (this.stategies) {
+            for(var i=0, len=this.strategies.length; i<len; i++) {
+                this.strategies[i].destroy();
+            }
+            this.strategies = null;
+        }
+        if (this.protocol) {
+            this.protocol.destroy();
+            this.protocol = null;
+        }
         this.destroyFeatures();
         this.features = null;
         this.selectedFeatures = null;
@@ -258,6 +288,11 @@ OpenLayers.Layer.Vector = OpenLayers.Class(OpenLayers.Layer, {
             this.renderer.map = this.map;
             this.renderer.setSize(this.map.getSize());
         }
+        if(this.strategies) {
+            for(var i=0, len=this.strategies.length; i<len; i++) {
+                this.strategies[i].activate();
+            }
+        }
     },
     
     /**
diff --git a/lib/OpenLayers/Protocol.js b/lib/OpenLayers/Protocol.js
new file mode 100755
index 0000000000..ba36f57e79
--- /dev/null
+++ b/lib/OpenLayers/Protocol.js
@@ -0,0 +1,169 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * Class: OpenLayers.Protocol
+ * Abstract vector layer protocol class.  Not to be instantiated directly.  Use
+ *     one of the protocol subclasses instead.
+ */
+OpenLayers.Protocol = OpenLayers.Class({
+    
+    /**
+     * Property: format
+     * {<OpenLayers.Format>}
+     */
+    format: null,
+    
+    /**
+     * Property: options
+     * Any options sent to the constructor.
+     */
+    options: null,
+    
+    /**
+     * Constructor: OpenLayers.Protocol
+     * Abstract class for vector protocols.  Create instances of a subclass.
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Util.extend(this, options);
+        this.options = options;
+    },
+
+    /**
+     * APIMethod: destroy
+     * Clean up the protocol.
+     */
+    destroy: function() {
+        this.options = null;
+        this.format = null;
+    },
+    
+    /**
+     * Method: read
+     * Construct a request for reading new features.
+     *
+     * Parameters:
+     * options - {Object} Optional object for configuring the request.
+     */
+    read: function() {
+    },
+    
+    
+    /**
+     * Method: create
+     * Construct a request for writing newly created features.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})} or
+     *            {<OpenLayers.Feature.Vector>}
+     * options - {Object} Optional object for configuring the request.
+     */
+    create: function() {
+    },
+    
+    /**
+     * Method: update
+     * Construct a request updating modified features.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})} or
+     *            {<OpenLayers.Feature.Vector>}
+     * options - {Object} Optional object for configuring the request.
+     */
+    update: function() {
+    },
+    
+    /**
+     * Method: delete
+     * Construct a request deleting a removed feature.
+     *
+     * Parameters:
+     * feature - {<OpenLayers.Feature.Vector>}
+     * options - {Object} Optional object for configuring the request.
+     */
+    "delete": function() {
+    },
+
+    /**
+     * Method: commit
+     * Go over the features and for each take action
+     * based on the feature state. Possible actions are create,
+     * update and delete.
+     *
+     * Parameters:
+     * features - {Array({<OpenLayers.Feature.Vector>})}
+     * options - {Object} Map of options, the keys of the map are
+     *           'create', 'update', and 'delete'
+     */
+    commit: function() {
+    },
+   
+    CLASS_NAME: "OpenLayers.Protocol" 
+});
+
+/**
+ * Class: OpenLayers.Protocol.Response
+ * Protocols return Response objects to their users.
+ */
+OpenLayers.Protocol.Response = new OpenLayers.Class({
+    /**
+     * Property: code
+     * {Integer} - OpenLayers.Protocol.Response.SUCCESS or
+     *             OpenLayers.Protocol.Response.FAILURE
+     */
+    code: null,
+
+    /**
+     * Property: features
+     * {Array({<OpenLayers.Feature.Vector>})} or {<OpenLayers.Feature.Vector>}
+     * The features returned in the response by the server.
+     */
+    features: null,
+
+    /**
+     * Property: reqFeatures
+     * {Array({<OpenLayers.Feature.Vector>})} or {<OpenLayers.Feature.Vector>}
+     * The features provided by the user and placed in the request by the
+     *      protocol.
+     */
+    reqFeatures: null,
+
+    /**
+     * Property: priv
+     */
+    priv: null,
+
+    /**
+     * Constructor: OpenLayers.Protocol.Response
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Util.extend(this, options);
+    },
+
+    /**
+     * Method: success
+     *
+     * Returns:
+     * {Boolean} - true on success, false otherwise
+     */
+    success: function() {
+        return !!(this.code & OpenLayers.Protocol.Response.SUCCESS_MASK);
+    },
+
+    CLASS_NAME: "OpenLayers.Protocol.Response"
+});
+
+OpenLayers.Protocol.Response.SUCCESS_MASK    = 0x000000ff;
+OpenLayers.Protocol.Response.SUCCESS         = 0x00000001;
+
+OpenLayers.Protocol.Response.FAILURE_MASK    = 0x0000ff00;
+OpenLayers.Protocol.Response.FAILURE         = 0x00000100;
diff --git a/lib/OpenLayers/Strategy.js b/lib/OpenLayers/Strategy.js
new file mode 100755
index 0000000000..f0e1afb691
--- /dev/null
+++ b/lib/OpenLayers/Strategy.js
@@ -0,0 +1,72 @@
+/* Copyright (c) 2006-2008 MetaCarta, Inc., published under the Clear BSD
+ * license.  See http://svn.openlayers.org/trunk/openlayers/license.txt for the
+ * full text of the license. */
+
+/**
+ * Class: OpenLayers.Strategy
+ * Abstract vector layer strategy class.  Not to be instantiated directly.  Use
+ *     one of the strategy subclasses instead.
+ */
+OpenLayers.Strategy = OpenLayers.Class({
+    
+    /**
+     * Property: layer
+     * {<OpenLayers.Layer.Vector>}
+     */
+    layer: null,
+    
+    /**
+     * Property: options
+     * {Object} Any options sent to the constructor.
+     */
+    options: null,
+
+    /**
+     * Constructor: OpenLayers.Strategy
+     * Abstract class for vector strategies.  Create instances of a subclass.
+     *
+     * Parameters:
+     * options - {Object} Optional object whose properties will be set on the
+     *     instance.
+     */
+    initialize: function(options) {
+        OpenLayers.Util.extend(this, options);
+        this.options = options;
+    },
+    
+    /**
+     * APIMethod: destroy
+     * Clean up the strategy.
+     */
+    destroy: function() {
+        this.deactivate();
+        this.layer = null;
+    },
+
+    /**
+     * Method: setLayer.
+     *
+     * Parameters:
+     * {<OpenLayers.Layer.Vector>}
+     */
+    setLayer: function(layer) {
+        this.layer = layer;
+    },
+    
+    /**
+     * Method: activate
+     * Activate the strategy.  Register any listeners, do appropriate setup.
+     */
+    activate: function() {
+    },
+    
+    /**
+     * Method: deactivate
+     * Deactivate the strategy.  Unregister any listeners, do appropriate
+     *     tear-down.
+     */
+    deactivate: function() {
+    },
+   
+    CLASS_NAME: "OpenLayers.Strategy" 
+});
diff --git a/tests/Protocol.html b/tests/Protocol.html
new file mode 100644
index 0000000000..3ff909497f
--- /dev/null
+++ b/tests/Protocol.html
@@ -0,0 +1,30 @@
+<html>
+<head>
+  <script src="../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_initialize(t) {
+        t.plan(2);
+        var options = {};
+        var protocol = new OpenLayers.Protocol(options);
+
+        t.ok(protocol instanceof OpenLayers.Protocol,
+             "new OpenLayers.Protocol returns object" );
+        t.eq(protocol.options, options, "constructor sets this.options");
+    }
+    
+    function test_destroy(t) {
+        t.plan(1);
+        var protocol = new OpenLayers.Protocol({
+            format: 'foo'
+        });
+        protocol.destroy();
+
+        t.eq(protocol.format, null, "destroy nullify protocol.format");
+    }
+
+  </script>
+</head>
+<body>
+</body>
+</html>
diff --git a/tests/Strategy.html b/tests/Strategy.html
new file mode 100644
index 0000000000..ff59028c3c
--- /dev/null
+++ b/tests/Strategy.html
@@ -0,0 +1,30 @@
+<html>
+<head>
+  <script src="../lib/OpenLayers.js"></script>
+  <script type="text/javascript">
+
+    function test_initialize(t) {
+        t.plan(2);
+        var options = {};
+        var strategy = new OpenLayers.Strategy(options);
+
+        t.ok(strategy instanceof OpenLayers.Strategy,
+             "new OpenLayers.Strategy returns object" );
+        t.eq(strategy.options, options, "constructor sets this.options");
+    }
+    
+    function test_destroy(t) {
+        t.plan(1);
+        var strategy = new OpenLayers.Strategy({
+            layer: 'foo'
+        });
+        strategy.destroy();
+
+        t.eq(strategy.layer, null, "destroy nullify protocol.layer");
+    }
+
+  </script>
+</head>
+<body>
+</body>
+</html>
diff --git a/tests/list-tests.html b/tests/list-tests.html
index ddeeaed9e7..5e5c5cbbac 100644
--- a/tests/list-tests.html
+++ b/tests/list-tests.html
@@ -110,6 +110,7 @@
     <li>Popup/AnchoredBubble.html</li>
     <li>Popup/FramedCloud.html</li>
     <li>Projection.html</li>
+    <li>Protocol.html</li>
     <li>Renderer.html</li>
     <li>Renderer/Elements.html</li>
     <li>Renderer/SVG.html</li>
@@ -117,6 +118,7 @@
     <li>Request.html</li>
     <li>Request/XMLHttpRequest.html</li>
     <li>Rule.html</li>
+    <li>Strategy.html</li>
     <li>Style.html</li>
     <li>StyleMap.html</li>
     <li>Tile.html</li>