diff --git a/Control/Arrow/Constrained.hs b/Control/Arrow/Constrained.hs
--- a/Control/Arrow/Constrained.hs
+++ b/Control/Arrow/Constrained.hs
@@ -53,9 +53,9 @@
     -- * Alternative composition notation
     , (>>>), (<<<)
     -- * Proxies for cartesian categories
-    , CartesianProxy(..)
-    , genericProxyCombine, genericUnit, genericAlg1to2, genericAlg2to1, genericAlg2to2
-    , PointProxy(..), genericPoint
+    , CartesianAgent(..)
+    , genericAgentCombine, genericUnit, genericAlg1to2, genericAlg2to1, genericAlg2to2
+    , PointAgent(..), genericPoint
     -- * Misc utility
     -- ** Conditionals
     , choose, ifThenElse
@@ -365,60 +365,60 @@
  
 
 
-genericProxyCombine :: ( HasProxy k, PreArrow k
+genericAgentCombine :: ( HasAgent k, PreArrow k
                        , Object k a, ObjectPair k b c, Object k d )
-     => k (b,c) d -> GenericProxy k a b -> GenericProxy k a c -> GenericProxy k a d
-genericProxyCombine m (GenericProxy v) (GenericProxy w)
-       = GenericProxy $ m . (v &&& w)
+     => k (b,c) d -> GenericAgent k a b -> GenericAgent k a c -> GenericAgent k a d
+genericAgentCombine m (GenericAgent v) (GenericAgent w)
+       = GenericAgent $ m . (v &&& w)
   
-genericUnit :: ( PreArrow k, HasProxy k, Object k a )
-        => GenericProxy k a (UnitObject k)
-genericUnit = GenericProxy terminal
+genericUnit :: ( PreArrow k, HasAgent k, Object k a )
+        => GenericAgent k a (UnitObject k)
+genericUnit = GenericAgent terminal
 
 
-class (Morphism k, HasProxy k) => CartesianProxy k where
+class (Morphism k, HasAgent k) => CartesianAgent k where
   alg1to2 :: ( Object k a, ObjectPair k b c
           ) => (forall q . Object k q
-                 => ProxyVal k q a -> (ProxyVal k q b, ProxyVal k q c) )
+                 => AgentVal k q a -> (AgentVal k q b, AgentVal k q c) )
                -> k a (b,c)
   alg2to1 :: ( ObjectPair k a b, Object k c
           ) => (forall q . Object k q
-                 => ProxyVal k q a -> ProxyVal k q b -> ProxyVal k q c )
+                 => AgentVal k q a -> AgentVal k q b -> AgentVal k q c )
                -> k (a,b) c
   alg2to2 :: ( ObjectPair k a b, ObjectPair k c d
           ) => (forall q . Object k q
-                 => ProxyVal k q a -> ProxyVal k q b -> (ProxyVal k q c, ProxyVal k q d) )
+                 => AgentVal k q a -> AgentVal k q b -> (AgentVal k q c, AgentVal k q d) )
                -> k (a,b) (c,d)
 
 genericAlg1to2 :: ( PreArrow k, u ~ UnitObject k
                   , Object k a, ObjectPair k b c
                   ) => ( forall q . Object k q
-                      => GenericProxy k q a -> (GenericProxy k q b, GenericProxy k q c) )
+                      => GenericAgent k q a -> (GenericAgent k q b, GenericAgent k q c) )
                -> k a (b,c)
-genericAlg1to2 f = runGenericProxy b &&& runGenericProxy c
- where (b,c) = f $ GenericProxy id
+genericAlg1to2 f = runGenericAgent b &&& runGenericAgent c
+ where (b,c) = f $ GenericAgent id
 genericAlg2to1 :: ( PreArrow k, u ~ UnitObject k
                   , ObjectPair k a u, ObjectPair k a b, ObjectPair k b u, ObjectPair k b a
                   ) => ( forall q . Object k q
-                      => GenericProxy k q a -> GenericProxy k q b -> GenericProxy k q c )
+                      => GenericAgent k q a -> GenericAgent k q b -> GenericAgent k q c )
                -> k (a,b) c
-genericAlg2to1 f = runGenericProxy $ f (GenericProxy fst) (GenericProxy snd)
+genericAlg2to1 f = runGenericAgent $ f (GenericAgent fst) (GenericAgent snd)
 genericAlg2to2 :: ( PreArrow k, u ~ UnitObject k
                   , ObjectPair k a u, ObjectPair k a b, ObjectPair k c d
                   , ObjectPair k b u, ObjectPair k b a
                   ) => ( forall q . Object k q
-                      => GenericProxy k q a -> GenericProxy k q b 
-                         -> (GenericProxy k q c, GenericProxy k q d) )
+                      => GenericAgent k q a -> GenericAgent k q b 
+                         -> (GenericAgent k q c, GenericAgent k q d) )
                -> k (a,b) (c,d)
-genericAlg2to2 f = runGenericProxy c &&& runGenericProxy d
- where (c,d) = f (GenericProxy fst) (GenericProxy snd)
+genericAlg2to2 f = runGenericAgent c &&& runGenericAgent d
+ where (c,d) = f (GenericAgent fst) (GenericAgent snd)
 
 
-class (HasProxy k, ProxyVal k a x ~ p a x) 
-           => PointProxy p k a x | p -> k where
+class (HasAgent k, AgentVal k a x ~ p a x) 
+           => PointAgent p k a x | p -> k where
   point :: (Object k a, Object k x) => x -> p a x
 
 genericPoint :: ( WellPointed k, Object k a, ObjectPoint k x )
-       => x -> GenericProxy k a x
-genericPoint x = GenericProxy $ const x
+       => x -> GenericAgent k a x
+genericPoint x = GenericAgent $ const x
 
diff --git a/Control/Category/Constrained.hs b/Control/Category/Constrained.hs
--- a/Control/Category/Constrained.hs
+++ b/Control/Category/Constrained.hs
@@ -31,9 +31,9 @@
           , ConstrainedCategory (ConstrainedMorphism)
           , constrained, unconstrained
             -- * Global-element proxies
-          , HasProxy (..)
-          , genericAlg, genericProxyMap
-          , GenericProxy (..)
+          , HasAgent (..)
+          , genericAlg, genericAgentMap
+          , GenericAgent (..)
             -- * Utility
           , inCategoryOf
           , CatTagged
@@ -362,39 +362,39 @@
 
 infixr 0 $~
 
--- | A proxy value is a \"general representation\" of a category's
+-- | An agent value is a \"general representation\" of a category's
 --   values, i.e. /global elements/. This is useful to define certain
 --   morphisms (including ones that can't just \"inherit\" from '->'
 --   with 'Control.Arrow.Constrained.arr') in ways other than point-free
 --   composition pipelines. Instead, you can write algebraic expressions
 --   much as if dealing with actual values of your category's objects,
---   but using the proxy type which is restricted so any function
+--   but using the agent type which is restricted so any function
 --   defined as such a lambda-expression qualifies as a morphism 
 --   of that category.
-class (Category k) => HasProxy k where
-  type ProxyVal k a v :: *
-  type ProxyVal k a v = GenericProxy k a v
+class (Category k) => HasAgent k where
+  type AgentVal k a v :: *
+  type AgentVal k a v = GenericAgent k a v
   alg :: ( Object k a, Object k b
          ) => (forall q . Object k q
-                 => ProxyVal k q a -> ProxyVal k q b) -> k a b
+                 => AgentVal k q a -> AgentVal k q b) -> k a b
   ($~) :: ( Object k a, Object k b, Object k c 
-          ) => k b c -> ProxyVal k a b -> ProxyVal k a c
+          ) => k b c -> AgentVal k a b -> AgentVal k a c
 
-data GenericProxy k a v = GenericProxy { runGenericProxy :: k a v }
+data GenericAgent k a v = GenericAgent { runGenericAgent :: k a v }
 
-genericAlg :: ( HasProxy k, Object k a, Object k b )
+genericAlg :: ( HasAgent k, Object k a, Object k b )
         => ( forall q . Object k q
-             => GenericProxy k q a -> GenericProxy k q b ) -> k a b
-genericAlg f = runGenericProxy . f $ GenericProxy id
+             => GenericAgent k q a -> GenericAgent k q b ) -> k a b
+genericAlg f = runGenericAgent . f $ GenericAgent id
 
-genericProxyMap :: ( HasProxy k, Object k a, Object k b, Object k c )
-        => k b c -> GenericProxy k a b -> GenericProxy k a c
-genericProxyMap m (GenericProxy v) = GenericProxy $ m . v
+genericAgentMap :: ( HasAgent k, Object k a, Object k b, Object k c )
+        => k b c -> GenericAgent k a b -> GenericAgent k a c
+genericAgentMap m (GenericAgent v) = GenericAgent $ m . v
 
 
 
-instance HasProxy (->) where
-  type ProxyVal (->) a b = b
+instance HasAgent (->) where
+  type AgentVal (->) a b = b
   alg f = f
   ($~) = ($)
 
diff --git a/constrained-categories.cabal b/constrained-categories.cabal
--- a/constrained-categories.cabal
+++ b/constrained-categories.cabal
@@ -1,5 +1,5 @@
 Name:                constrained-categories
-Version:             0.1.0.0
+Version:             0.2.0.0
 Category:            control
 Synopsis:            Constrained clones of the category-theory type classes, using ConstraintKinds.
 Description:         Haskell has, and makes great use of, powerful facilities from category
@@ -27,7 +27,7 @@
 License:             GPL-3
 License-file:        COPYING
 Author:              Justus Sagemüller
-Maintainer:          (@) sagemuej $ smail.uni-koeln.de
+Maintainer:          (@) sagemueller $ geo.uni-koeln.de
 Homepage:            https://github.com/leftaroundabout/constrained-categories
 Build-Type:          Simple
 Cabal-Version:       >=1.10