diff --git a/SpecRunner.html b/SpecRunner.html
index 36700ea..543d6e9 100644
--- a/SpecRunner.html
+++ b/SpecRunner.html
@@ -23,6 +23,7 @@
   <script type="text/javascript" src="spec/hasMany.js"></script>
   <script type="text/javascript" src="spec/hasOne.js"></script>
   <script type="text/javascript" src="spec/belongsTo.js"></script>
+  <script type="text/javascript" src="spec/delegation.js"></script>
 
   <script type="text/javascript">
     (function() {
diff --git a/backbone.associations.js b/backbone.associations.js
index 7ca4979..83d965c 100644
--- a/backbone.associations.js
+++ b/backbone.associations.js
@@ -1,8 +1,37 @@
 Backbone.AssociativeModel = Backbone.Model.extend({
     constructor: function(attributes, options) {
+        var attrsToDelegate = {},
+            delegatedAttrNames = _(_(this.delegateAttributes).chain().keys().map(function(k) {
+                return k.split(/\s+/);
+            }).flatten().value());
+
+
+        //extract any delegate attrs from attributes hash
+        _(attributes).each(function(value, attrKey) {
+            if (delegatedAttrNames.include(attrKey)) {
+                attrsToDelegate[attrKey] = value;
+                delete attributes[attrKey];
+            }
+        },  this  );
+
+        //set all non-delegated attrs via normal instantiation
         Backbone.Model.prototype.constructor.apply(this, arguments);
+
         //trigger special change events to update attributes obtained through associations when those associations are set during initial instantiation
         _(this.attributes).each(function(v,k) {  this.trigger('change:'+k, this, this.get(k), options);  },  this);
+
+        // set up delegation for delegated attributes
+        this._delegateAttributes(this.delegateAttributes);
+
+        //set all delegated attrs now that their associations have been set
+        var valid = this.set(attrsToDelegate);
+
+        //set all delegate methods now that their associations have been set
+        _(this.delegateMethods).each(function(delegateModelName, delegateMethodName){
+            this._delegateMethods(delegateMethodName).toAttribute(delegateModelName);
+        },  this  );
+
+        return valid;
     },
 
     set: function(attributes, options) {
@@ -261,6 +290,145 @@ Backbone.AssociativeModel = Backbone.Model.extend({
         },  this  );
 
         return json;
+    },
+
+    /************************ DELEGATION ************************/
+    // Override this with a hash of attributes to delegate.
+    // Keys are space-delimited attribute names; values are delegate model names.
+    delegateAttributes: {},
+
+    // Override this with a hash of methods to delegate.
+    // Keys are space-delimited method names; values are delegate model names.
+    delegateMethods: {},
+
+    _delegateMethods: function(methodName) {
+        var self = this,
+            methodNames = methodName.split(/\s+/);
+
+        return {
+            toAttribute: function(delegateModelAttributeName) {
+                _.each(methodNames, function(methodName) {
+                    self[methodName] = function() {
+                        var delegateModel = this.get(delegateModelAttributeName);
+                        return delegateModel ? delegateModel[methodName].apply(delegateModel, arguments) : undefined;
+                    };
+                });
+            }
+        };
+    },
+
+    delegateAttribute: function(attrName) {
+        return this.delegateAttributesInternal(attrName);
+    },
+
+    _delegateAttributes: function(delegatedAttrMap) {
+    /*
+        looks like:
+        {
+            'attr1 attr2 attr3': 'delegateModel'
+        }
+     */
+        _(delegatedAttrMap).each(function(delegateModel, delegatedAttributes) {
+            this.delegateAttributesInternal(delegatedAttributes).toAttribute(delegateModel);
+        },  this  );
+    },
+
+    delegateAttributesInternal: function(attributeNames) {
+        var self = this,
+            delegatedAttrsMap = this.delegatedAttrsMap || this.setupDelegatedAttributes();
+
+        return {
+            toAttribute: function(delegateModelAttributeName) {
+                var delegateModel = self.get(delegateModelAttributeName),
+                    delegatedAttrChanged;
+
+                var attributeNameList = attributeNames.split(/\s+/);
+                _.each(attributeNameList, function(attributeName) {
+                    delegatedAttrsMap[attributeName] = delegateModelAttributeName;
+
+                    delegatedAttrChanged = function(delegateModel, changedAttrVal, options) {
+                        this.trigger('change:'+attributeName, delegateModel, changedAttrVal, options);
+                    };
+
+                    if (delegateModel) {
+                        delegateModel.on('change:'+attributeName, delegatedAttrChanged, self);
+
+                        self.on('change:'+delegateModelAttributeName, function(delegatingModel, delegateModel, options) {
+                            if (!delegateModel) delegatingModel.off('change:'+attributeName, delegatedAttrChanged, self);
+                        });
+                    } else {
+                        self.on('change:'+delegateModelAttributeName, function(delegatingModel, delegateModel, options) {
+                            if (delegateModel) delegatingModel.on('change:'+attributeName, delegatedAttrChanged, self);
+                        });
+                    }
+                });
+            }
+        };
+    },
+
+    setupDelegatedAttributes: function() {
+        this.delegatedAttrsMap = {};
+        this.get = this.getWithDelegates;
+        this.set = this.setWithDelegates;
+        return this.delegatedAttrsMap;
+    },
+
+    getWithDelegates: function(attrName) {
+        //NOTE: This overrides Backbone.AssociativeModel.get()
+        var directAttrVal = this.attributes[attrName];
+        if (typeof directAttrVal !== 'undefined') return directAttrVal;
+
+        if (this.delegatedAttrsMap[attrName]) {
+            var delegateModel = this.get(this.delegatedAttrsMap[attrName]);
+            if (delegateModel) return delegateModel.get(attrName);
+        }
+    },
+
+    setWithDelegates: function(key, value, options) {
+        //NOTE: This overrides Backbone.AssociativeModel.set()
+        var attrHash;
+        if (_.isObject(key)) {
+            attrHash = _.clone(key); //by cloning we avoid losing delegated values on redo of #setWithUndoableCmd above
+            options = value;
+        } else {
+            attrHash = {};
+            attrHash[key] = value;
+        }
+
+        options || (options = {});
+
+        // Run validation on host model before setting, so that host
+        // model can run its own validations against delegated
+        // attributes.
+        if (!this._validate(attrHash, options)) return false;
+
+        var delegatedAttrsMap = this.delegatedAttrsMap,
+            delegatedAttrNames = _(attrHash).chain()
+                                            .keys()
+                                            .select(function(key) {
+                                                return _(delegatedAttrsMap).chain().keys().include(key).value();
+                                            })
+                                            .value();
+
+        if (delegatedAttrNames.length > 0) {
+            var delegatedAttrsGroupedByDelegateModel =  _(delegatedAttrNames).groupBy(function(name) {  return delegatedAttrsMap[name];  }),
+                delegateAttrHashForOneModel, delegateModel;
+
+            _(delegatedAttrsGroupedByDelegateModel).each(function(delegateAttrNameArray, delegateModelName) {
+                delegateAttrHashForOneModel = {};
+
+                _(delegateAttrNameArray).each(function(delegateAttrName) {
+                    delegateAttrHashForOneModel[delegateAttrName] = attrHash[delegateAttrName];
+                    delete attrHash[delegateAttrName];
+                });
+
+                delegateModel = this.get(delegateModelName);
+                delegateModel.set(delegateAttrHashForOneModel, options);
+            },  this  );
+        }
+
+        if (  _(attrHash).isEmpty() === false  )  Backbone.AssociativeModel.prototype.set.apply(this, [attrHash, options]);
+        return this;
     }
 },
 {
diff --git a/spec/delegation.js b/spec/delegation.js
new file mode 100644
index 0000000..8f1dae4
--- /dev/null
+++ b/spec/delegation.js
@@ -0,0 +1,229 @@
+describe("`delegateAttributes` property, for delegating attributes on instantiation", function() {
+    beforeEach(function() {
+        DelegateModel = Backbone.AssociativeModel.extend({
+            associations: function() {
+                this.hasOne('modelWithDelegatedAttr').viaReverseKey('delegateModel');
+            }
+        });
+
+        ModelWithDelegatedAttr = Backbone.AssociativeModel.extend({
+            associations: function() {  this.hasOne('delegateModel');  },
+
+            delegateAttributes: {
+                'delegatedAttrName': 'delegateModel'
+            }
+        });
+
+        this.delegate = new DelegateModel();
+        this.delegating = new ModelWithDelegatedAttr({
+            delegateModel: this.delegate,
+            delegatedAttrName: 'Yes'
+        });
+    });
+
+    it("does not set the attribute directly on the delegating model", function() {
+        expect(this.delegating.attributes.delegatedAttrName).not.toBeDefined();
+    });
+});
+
+describe("`delegateMethods` property", function() {
+    beforeEach(function() {
+        DelegateModel = Backbone.AssociativeModel.extend({
+            associations: function() {
+                this.hasOne('modelWithDelegatedAttr').viaReverseKey('delegateModel');
+            },
+            delegatedMethod: function delegatedMethod(word) {
+                return 'blue';
+            }
+        });
+
+        ModelWithDelegatedAttr = Backbone.AssociativeModel.extend({
+            associations: function() {
+                this.hasOne('delegateModel');
+            },
+
+            delegateMethods: {
+                'delegatedMethod': 'delegateModel',
+                'delegatedMethod1 delegatedMethod2': 'delegateModel'
+            }
+        });
+
+        this.delegateModel = new DelegateModel();
+        this.subject = new ModelWithDelegatedAttr({delegateModel: this.delegateModel});
+    });
+
+    it("calls the delegated method on the delegate model", function() {
+        spyOn(this.delegateModel, "delegatedMethod");
+        this.subject.delegatedMethod('howdy');
+        expect(this.delegateModel.delegatedMethod).toHaveBeenCalledWith('howdy');
+    });
+
+    it("when calling a delegated method on an attribute that doesn't exist, it returns undefined", function() {
+        this.subject.get('delegateModel').destroy();
+        expect(_.isUndefined(this.subject.delegatedMethod())).toBeTruthy();
+    });
+
+    it("when a model has a delegateModel as an attribute, then that delegateModel gets destroyed, then the first model gets a second delegateModel in its place, that second delegateModel should have delegatedMethods called on it", function() {
+        this.subject.get('delegateModel').destroy();
+        var newDelegateModel =  new DelegateModel();
+        this.subject.set({delegateModel: newDelegateModel});
+
+        spyOn(newDelegateModel, "delegatedMethod");
+        this.subject.delegatedMethod('yo');
+        expect(newDelegateModel.delegatedMethod).toHaveBeenCalledWith('yo');
+    });
+
+    it("when passing a list of method names, those methods are called on the delegate model from the delegating model", function() {
+        this.delegateModel.delegatedMethod1 = function () {};
+        this.delegateModel.delegatedMethod2 = function () {};
+
+        spyOn(this.delegateModel, "delegatedMethod1");
+        spyOn(this.delegateModel, "delegatedMethod2");
+
+        this.subject.delegatedMethod1('yo1');
+        this.subject.delegatedMethod2('yo2');
+
+        expect(this.delegateModel.delegatedMethod1).toHaveBeenCalledWith('yo1');
+        expect(this.delegateModel.delegatedMethod2).toHaveBeenCalledWith('yo2');
+    });
+
+    describe("#delegateAttributesInternal", function() {
+        beforeEach(function() {
+            DelegateModel = Backbone.AssociativeModel.extend({});
+
+            ModelWithDelegatedAttr = Backbone.AssociativeModel.extend({
+                associations: function() {  this.hasOne('delegateModel');  },
+                initialize: function() {
+                    this.delegateAttributesInternal("delegatedAttrName1 delegatedAttrName2").toAttribute("delegateModel");
+                }
+            });
+
+            this.delegateModel = new DelegateModel();
+            this.subject = new ModelWithDelegatedAttr().set({delegateModel: this.delegateModel});
+        });
+
+        it("sets the delegated attribute values on the delegate model", function() {
+            this.subject.set({
+                delegatedAttrName1: 300,
+                delegatedAttrName2: 400
+            });
+
+            expect(this.delegateModel.get('delegatedAttrName1')).toEqual(300);
+            expect(this.delegateModel.get('delegatedAttrName2')).toEqual(400);
+        });
+
+        it("retrieves the delegated attributes from the delegatING model", function() {
+            this.delegateModel.set({ delegatedAttrName1: 300 });
+            expect(this.subject.get('delegatedAttrName1')).toEqual(300);
+        });
+
+        describe("when the delegate model is destroyed", function() {
+            it("returns undefined for attributes delegated to the destroyed delegate model", function() {
+                this.delegateModel.set({ delegatedAttrName1: 300 });
+                this.delegateModel.destroy();
+                expect(this.subject.get('delegatedAttrName1')).toBeUndefined();
+            });
+        });
+
+        describe("when a different delegate model is set for the same delegated model attribute", function() {
+            it("the delegatING model retrieves delegated attrs from the new delegate model", function() {
+                //first delegate model
+                this.delegateModel.set({ delegatedAttrName1: 300 });
+                expect(this.subject.get('delegatedAttrName1')).toEqual(300);
+
+
+                //second delegate model
+                var secondDelegateModel = new DelegateModel({delegatedAttrName1: 500});
+                this.subject.set({delegateModel: secondDelegateModel});
+                expect(this.subject.get('delegatedAttrName1')).toEqual(500);
+            });
+        });
+    });
+});
+
+describe("#delegateAttribute", function() {
+    beforeEach(function() {
+        DelegateModel = Backbone.AssociativeModel.extend({
+            associations: function() {
+                this.hasOne('modelWithDelegatedAttr').viaReverseKey('delegateModel');
+            }
+        });
+
+        ModelWithDelegatedAttr = Backbone.AssociativeModel.extend({
+            associations: function() {  this.hasOne('delegateModel');  },
+            initialize: function() {
+                this.delegateAttribute('delegatedAttrName').toAttribute('delegateModel');
+            }
+        });
+
+        this.delegateModel = new DelegateModel();
+        this.subject = new ModelWithDelegatedAttr({delegateModel: this.delegateModel});
+    });
+
+    it("sets the attribute value on the delegate model", function() {
+        this.subject.set({"delegatedAttrName": 22});
+        expect(this.subject.get("delegatedAttrName")).toEqual(22);
+    });
+
+    it("lets the model with delegated attr retrieve the value of the delegated attr", function() {
+        this.subject.set({"delegatedAttrName": 22});
+        expect(this.subject.get("delegatedAttrName")).toEqual(22);
+    });
+
+    it("calls #validate on the model with delegated attr prior to setting on the delegate model", function() {
+        this.subject.validate = function() {};
+        spyOn(this.subject, 'validate');
+        this.subject.set({"delegatedAttrName": 22});
+        expect(this.subject.validate).wasCalled();
+    });
+
+    it("change:attrName events fire on delegating model for attrs it has delegated", function() {
+        this.changeAttrCallBack = function(delegateModel, value, options){
+            expect(this.get('delegatedAttrName') === 'changed').toBeTruthy();
+        };
+
+        this.subject.on('change:delegatedAttrName', this.changeAttrCallBack, this.subject);
+        this.subject.set('delegatedAttrName', 'changed');
+        this.subject.off('change:delegatedAttrName', this.changeAttrCallBack, this.subject); //necessary otherwise later tests fail
+    });
+
+    it("modelWithDelegatedAttr#previous(delegatedAttrName) does not return the previous value of the delegatedAttr, but the delegateModel argument does", function() {
+        this.testPreviousCallBack = function(delegateModel, value, options){
+            expect(this.previous('delegatedAttrName') === 'original').toBeFalsy();
+            expect(delegateModel.previous('delegatedAttrName') === 'original').toBeTruthy();
+        };
+
+        this.subject.set('delegatedAttrName', 'original');
+        this.subject.on('change:delegatedAttrName', this.testPreviousCallBack, this.subject);
+        this.subject.set('delegatedAttrName', 'changed');
+        this.subject.off('change:delegatedAttrName', this.testPreviousCallBack, this.subject); //necessary otherwise later tests fail
+    });
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+