 +        print(instance)
 +        print(value)
 +
-+        self._value = value
++        self._value = Proxy(value)
 +
 +class Result(object):
 +    """Create a new Result Object

diff --git a/circuits/core/values.py b/circuits/core/values.py
--- a/circuits/core/values.py
+++ b/circuits/core/values.py
@@ -22,11 +22,31 @@
 
         super(ValueChanged, self).__init__(value)
 
+class Value(object):
 
-class Value(object):
-    """Create a new future Value Object
+    def __init__(self, value=None):
+        super(Value, self).__init__()
 
-    Creates a new future Value Object which is used by Event Objects and the
+        self._value = value
+
+    def __get__(self, instance, owner):
+        print("Retriving value...")

-    value = property(getValue, setValue, None, "Value of this Value")
+        format = "<Result (done: %r errors: %r) for %r>"
+        return format % (self.done, self.errors, self.event)
diff --git a/tmp/lazy_evaluation.diff b/tmp/lazy_evaluation.diff
--- a/tmp/lazy_evaluation.diff
+++ b/tmp/lazy_evaluation.diff
@@ -48,19 +48,111 @@
 diff --git a/circuits/core/values.py b/circuits/core/values.py
 --- a/circuits/core/values.py
 +++ b/circuits/core/values.py
-@@ -22,11 +22,31 @@
+@@ -22,11 +22,124 @@
  
          super(ValueChanged, self).__init__(value)
  
-+class Value(object):
++class Proxy(object):
++
++    __slots__ = ["_obj", "__weakref__"]
++
++    def __init__(self, obj):
++        object.__setattr__(self, "_obj", obj)
++    
++
++    # proxying (special cases)
++    #
++    def __getattribute__(self, name):
++        print("__getattribute__")
++        print(name)
++        return getattr(object.__getattribute__(self, "_obj"), name)
++    def __delattr__(self, name):
++        print("__delattr__")
++        print(name)
++        delattr(object.__getattribute__(self, "_obj"), name)
++    def __setattr__(self, name, value):
++        print("__setattr__")
++        print(name)
++        print(value)
++        setattr(object.__getattribute__(self, "_obj"), name, value)
++
++    def __nonzero__(self):
++        print("__nonzero__")
++        return bool(object.__getattribute__(self, "_obj"))
++    def __str__(self):
++        print("__str__")
++        return str(object.__getattribute__(self, "_obj"))
++    def __repr__(self):
++        print("__repr__")
++        return repr(object.__getattribute__(self, "_obj"))
++
++    #
++    # factories
++    #
++    _special_names = [
++        "__abs__", "__add__", "__and__", "__call__", "__cmp__", "__coerce__", 
++        "__contains__", "__delitem__", "__delslice__", "__div__", "__divmod__", 
++        "__eq__", "__float__", "__floordiv__", "__ge__", "__getitem__", 
++        "__getslice__", "__gt__", "__hash__", "__hex__", "__iadd__", "__iand__",
++        "__idiv__", "__idivmod__", "__ifloordiv__", "__ilshift__", "__imod__", 
++        "__imul__", "__int__", "__invert__", "__ior__", "__ipow__", "__irshift__", 
++        "__isub__", "__iter__", "__itruediv__", "__ixor__", "__le__", "__len__", 
++        "__long__", "__lshift__", "__lt__", "__mod__", "__mul__", "__ne__", 
++        "__neg__", "__oct__", "__or__", "__pos__", "__pow__", "__radd__", 
++        "__rand__", "__rdiv__", "__rdivmod__", "__reduce__", "__reduce_ex__", 
++        "__repr__", "__reversed__", "__rfloorfiv__", "__rlshift__", "__rmod__", 
++        "__rmul__", "__ror__", "__rpow__", "__rrshift__", "__rshift__", "__rsub__", 
++        "__rtruediv__", "__rxor__", "__setitem__", "__setslice__", "__sub__", 
++        "__truediv__", "__xor__", "next",
++    ]
++    
++    @classmethod
++    def _create_class_proxy(cls, theclass):
++        """creates a proxy for the given class"""
++        
++        def make_method(name):
++            def method(self, *args, **kw):
++                print(name)
++                print(args)
++                print(kw)
++                return getattr(object.__getattribute__(self, "_obj"),
++                        name)(*args, **kw)
++            return method
++        
++        namespace = {}
++        for name in cls._special_names:
++            if hasattr(theclass, name):
++                namespace[name] = make_method(name)
++        return type("%s(%s)" % (cls.__name__, theclass.__name__), (cls,), namespace)
++    
++    def __new__(cls, obj, *args, **kwargs):
++        """
++        creates an proxy instance referencing `obj`. (obj, *args, **kwargs) are
++        passed to this class" __init__, so deriving classes can define an 
++        __init__ method of their own.
++        note: _class_proxy_cache is unique per deriving class (each deriving
++        class must hold its own cache)
++        """
++        try:
++            cache = cls.__dict__["_class_proxy_cache"]
++        except KeyError:
++            cls._class_proxy_cache = cache = {}
++        try:
++            theclass = cache[obj.__class__]
++        except KeyError:
++            cache[obj.__class__] = theclass = cls._create_class_proxy(obj.__class__)
++        ins = object.__new__(theclass)
++        theclass.__init__(ins, obj, *args, **kwargs)
++        return ins
  
--class Value(object):
+ class Value(object):
 -    """Create a new future Value Object
+ 
+-    Creates a new future Value Object which is used by Event Objects and the
 +    def __init__(self, value=None):
 +        super(Value, self).__init__()
- 
--    Creates a new future Value Object which is used by Event Objects and the
-+        self._value = value
++
++        self._value = Proxy(value)
 +
 +    def __get__(self, instance, owner):
 +        print("Retriving value...")
@@ -74,7 +166,7 @@
 +        print(instance)
 +        print(value)
 +
-+        self._value = value
++        self._value = Proxy(value)
 +
 +class Result(object):
 +    """Create a new Result Object
@@ -83,7 +175,7 @@
      Manager to store the result(s) of an Event Handler's exeuction of some
      Event in the system.
  
-@@ -39,90 +59,31 @@
+@@ -39,90 +152,31 @@
      :param onSet: The channel used when triggering ValueChagned events.
      :type  onSet: A (channel, target) tuple.
  
@@ -144,77 +236,4 @@
 -        return format % (value, self.result, self.errors, self.event)
 -
 -    def __str__(self):
--        "x.__str__() <==> str(x)"
--
--        return str(self.value)
--
--    def getValue(self):
--        value = self._value
--        while isinstance(value, Value):
--            value = value._value
--        return value
--
--    def setValue(self, value):
--        if isinstance(value, Value):
--            value._parent = self
--
--        if self.result and isinstance(self._value, list):
--            self._value.append(value)
--        elif self.result:
--            self._value = [self._value]
--            self._value.append(value)
--        else:
--            self._value = value
--
--        def notify(o, v):
--            if not isinstance(v, Value) and v is not None:
--                o.result = True
--                if o.manager is not None and o.onSet is not None:
--                    o.manager.fireEvent(ValueChanged(o), *o.onSet)
--            elif isinstance(v, Value):
--                o.errors = v.errors
--                o.result = v.result
--            if not o._parent == o:
--                o._parent.errors = o.errors
--                o._parent.result = o.result
--                notify(o._parent, v)
--        
--        notify(self, value)
--
--    value = property(getValue, setValue, None, "Value of this Value")
-+        format = "<Result (done: %r errors: %r) for %r>"
-+        return format % (self.done, self.errors, self.event)
-diff --git a/tmp/test_lazy_evaluation.py b/tmp/test_lazy_evaluation.py
-new file mode 100755
---- /dev/null
-+++ b/tmp/test_lazy_evaluation.py
-@@ -0,0 +1,29 @@
-+#!/usr/bin/env python
-+
-+from circuits import Component, Event
-+
-+class Test(Event):
-+    """Test Event"""
-+
-+class Foo(Event):
-+    """Foo Event"""
-+
-+class Bar(Event):
-+    """Bar Event"""
-+
-+class App(Component):
-+
-+    def foo(self):
-+        return 1
-+
-+    def bar(self):
-+        return 2
-+
-+    def test(self):
-+        a = self.fire(Foo())
-+        b = self.fire(Bar())
-+        return a.value + b.value
-+
-+from circuits import Debugger
-+app = App() + Debugger()
-+app.start()
+-        "x.__st
\ No newline at end of file
diff --git a/tmp/test_lazy_evaluation.py b/tmp/test_lazy_evaluation.py
new file mode 100755
--- /dev/null
