diff --git a/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs b/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs
index cf7d696..d0b27aa 100644
--- a/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs
+++ b/src/iSynaptic.Core.CodeGeneration/Modeling/Domain/AggregateSnapshotCodeAuthoringVisitor.cs
@@ -60,10 +60,8 @@ protected override Maybe<string> GetBaseMolecule(MoleculeSyntax molecule)
         {
             var aggregate = (AggregateSyntax)molecule.Parent;
 
-            var id = aggregate.GetIdTypeName(SymbolTable);
-
             return base.GetBaseMolecule(molecule)
-                       .Or(String.Format("AggregateSnapshot<{0}>", id));
+                       .Or("AggregateSnapshot");
         }
 
         protected override bool ShouldBeEquatable(MoleculeSyntax molecule)
diff --git a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
index 918b370..6660f50 100644
--- a/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/EventStoreAggregateRepository.cs
@@ -21,35 +21,26 @@
 // THE SOFTWARE.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
-
 using EventStore.ClientAPI;
 using EventStore.ClientAPI.Exceptions;
-using Newtonsoft.Json;
 using iSynaptic.Commons;
-using iSynaptic.Commons.Collections.Generic;
 using iSynaptic.Commons.Linq;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.Serialization;
+using Newtonsoft.Json;
 
 namespace iSynaptic.Core.Persistence
 {
-    public class EventStoreAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class EventStoreAggregateRepository : AggregateRepository
     {
         private static readonly Guid _offsetEventId = new Guid(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
         private static readonly EventData _offsetEvent = new EventData(_offsetEventId, "streamOffset", true, Encoding.Default.GetBytes("{}"), null);
 
         private readonly ILogicalTypeRegistry _logicalTypeRegistry;
-
         private readonly JsonSerializer _dataSerializer;
-        private readonly JsonSerializer _metadataSerializer;
-
         private readonly Func<IEventStoreConnection> _connectionFactory;
 
         public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, Func<IEventStoreConnection> connectionFactory)
@@ -61,11 +52,9 @@ public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, F
 
             var metadataSerializerSettings = JsonSerializerBuilder.BuildSettings(logicalTypeRegistry);
             metadataSerializerSettings.TypeNameHandling = TypeNameHandling.None;
-
-            _metadataSerializer = JsonSerializer.Create(metadataSerializerSettings);
         }
 
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
+        protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)
         {
             var maxCount = (maxVersion - minVersion) + 1;
 
@@ -102,16 +91,16 @@ protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(T
                     var events = resolvedEvents
                         .Select(x => x.Event.Data)
                         .Select(Encoding.Default.GetString)
-                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent<TIdentifier>>(x));
+                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent>(x));
 
-                    return new AggregateEventsLoadFrame<TIdentifier>(aggregateType, id, events);
+                    return new AggregateEventsLoadFrame(aggregateType, id, events);
                 }
 
                 return null;
             }
         }
 
-        protected async override Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
+        protected async override Task SaveEvents(AggregateEventsSaveFrame frame)
         {
             var aggregateType = frame.AggregateType;
             var id = frame.Id;
@@ -156,7 +145,7 @@ await cn.AppendToStreamAsync(
             }
         }
 
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
+        protected override async Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, int maxVersion)
         {
             using (var cn = _connectionFactory())
             {
@@ -174,7 +163,7 @@ protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapsh
                 {
                     throw new InvalidOperationException("Aggregate type is not specified in event stream metadata.");
                 }
-                
+
                 var resolvedEvent = (await cn.ReadStreamEventsForwardAsync(snapshotStreamId, 0, int.MaxValue, false).ConfigureAwait(false))
                     .ToMaybe()
                     .Where(x => x.Status == SliceReadStatus.Success)
@@ -184,21 +173,21 @@ protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapsh
                 var snapshot = resolvedEvent
                     .Select(x => x.Event.Data)
                     .Select(Encoding.Default.GetString)
-                    .Select(x => _dataSerializer.Deserialize<IAggregateSnapshot<TIdentifier>>(x))
+                    .Select(x => _dataSerializer.Deserialize<IAggregateSnapshot>(x))
                     .Where(x => x.Version <= maxVersion);
 
                 if (snapshot.HasValue)
                 {
                     Type aggregateType = _logicalTypeRegistry.LookupActualType(LogicalType.Parse(aggregateTypeString));
 
-                    return new AggregateSnapshotLoadFrame<TIdentifier>(aggregateType, id, snapshot.Value);
+                    return new AggregateSnapshotLoadFrame(aggregateType, id, snapshot.Value);
                 }
 
                 return null;
             }
         }
 
-        protected async override Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
+        protected async override Task SaveSnapshot(AggregateSnapshotSaveFrame frame)
         {
             using (var cn = _connectionFactory())
             {
@@ -235,7 +224,7 @@ await cn.AppendToStreamAsync(
                             snapshot.SnapshotId,
                             snapshot,
                             aggregateType)
-                    ).ConfigureAwait(false);    
+                    ).ConfigureAwait(false);
                 }
             }
         }
@@ -264,14 +253,24 @@ protected EventData BuildEventData(Guid id, object data, Type aggregateType)
                 null);
         }
 
-        protected virtual String BuildStreamIdentifier(TIdentifier id)
+        protected virtual String BuildStreamIdentifier(object id)
         {
             return _dataSerializer.Serialize(id);
         }
 
-        protected virtual String BuildSnapshotStreamIdentifier(TIdentifier id)
+        protected virtual String BuildSnapshotStreamIdentifier(object id)
         {
             return String.Format("{0}-snapshot", BuildStreamIdentifier(id));
         }
     }
-}
+
+    public class EventStoreAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
+        where TAggregate : class, IAggregate<TIdentifier>
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        public EventStoreAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, Func<IEventStoreConnection> connectionFactory)
+            :base(new EventStoreAggregateRepository(logicalTypeRegistry, connectionFactory))
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs b/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
index 4d1b07b..431dd9c 100644
--- a/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/InMemoryAggregateRepository.cs
@@ -27,18 +27,14 @@
 using iSynaptic.Commons;
 using iSynaptic.Commons.Collections.Generic;
 using iSynaptic.Modeling.Domain;
-using iSynaptic.Serialization;
 
 namespace iSynaptic.Core.Persistence
 {
-    public class InMemoryAggregateRepository<TAggregate, TIdentifier> : MementoBasedAggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class InMemoryAggregateRepository : MementoBasedAggregateRepository
     {
-        private readonly Dictionary<TIdentifier, AggregateMemento<TIdentifier>> _state =
-            new Dictionary<TIdentifier, AggregateMemento<TIdentifier>>();
+        private readonly Dictionary<object, AggregateMemento> _state = new Dictionary<object, AggregateMemento>();
 
-        protected override Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TIdentifier id)
+        protected override Task<Maybe<AggregateMemento>> TryLoadMemento(object id)
         {
             lock (_state)
             {
@@ -46,23 +42,33 @@ protected override Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TId
             }
         }
 
-        protected override async Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, AggregateMemento<TIdentifier>>>> mementoFactory)
+        protected override async Task StoreMemento(Func<Task<KeyValuePair<object, AggregateMemento>>> mementoFactory)
         {
             bool lockTaken = false;
-            
+
             try
             {
                 Monitor.Enter(_state, ref lockTaken);
 
                 var memento = await mementoFactory();
                 _state[memento.Key] = memento.Value;
-                
+
             }
             finally
             {
-                if(lockTaken)
+                if (lockTaken)
                     Monitor.Exit(_state);
             }
         }
     }
+
+    public class InMemoryAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
+        where TAggregate : class, IAggregate<TIdentifier>
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        public InMemoryAggregateRepository()
+            : base(new InMemoryAggregateRepository())
+        {
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs b/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
index 3dacd07..6c427ed 100644
--- a/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/InMemoryJsonAggregateRepository.cs
@@ -27,18 +27,14 @@
 using Newtonsoft.Json;
 using iSynaptic.Commons;
 using iSynaptic.Commons.Collections.Generic;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.Serialization;
 
 namespace iSynaptic.Core.Persistence
 {
-    public class InMemoryJsonAggregateRepository<TAggregate, TIdentifier> : MementoBasedAggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class InMemoryJsonAggregateRepository : MementoBasedAggregateRepository
     {
-        private readonly Dictionary<String, String> _state =
-            new Dictionary<String, String>();
+        private readonly Dictionary<String, String> _state = new Dictionary<String, String>();
 
         private readonly JsonSerializer _serializer;
 
@@ -47,27 +43,37 @@ public InMemoryJsonAggregateRepository(JsonSerializer serializer)
             _serializer = Guard.NotNull(serializer, "serializer");
         }
 
-        protected override Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TIdentifier id)
+        protected override Task<Maybe<AggregateMemento>> TryLoadMemento(object id)
         {
             return Task.FromResult(_state.TryGetValue(_serializer.Serialize(id))
-                       .Select(json => _serializer.Deserialize<AggregateMemento<TIdentifier>>(json)));
+                       .Select(json => _serializer.Deserialize<AggregateMemento>(json)));
         }
 
-        protected override async Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, AggregateMemento<TIdentifier>>>> mementoFactory)
+        protected override async Task StoreMemento(Func<Task<KeyValuePair<object, AggregateMemento>>> mementoFactory)
         {
             bool lockTaken = false;
             try
             {
                 Monitor.Enter(_state, ref lockTaken);
-                
+
                 var memento = await mementoFactory();
                 _state[_serializer.Serialize(memento.Key)] = _serializer.Serialize(memento.Value);
             }
             finally
             {
-                if(lockTaken)
+                if (lockTaken)
                     Monitor.Exit(_state);
             }
         }
     }
-}
+
+    public class InMemoryJsonAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
+        where TAggregate : class, IAggregate<TIdentifier>
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        public InMemoryJsonAggregateRepository(JsonSerializer serializer)
+            : base(new InMemoryJsonAggregateRepository(serializer))
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs b/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
index a772b7e..b6f13b5 100644
--- a/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/MementoBasedAggregateRepository.cs
@@ -31,34 +31,32 @@
 
 namespace iSynaptic.Core.Persistence
 {
-    public abstract class MementoBasedAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public abstract class MementoBasedAggregateRepository : AggregateRepository
     {
-        protected abstract Task<Maybe<AggregateMemento<TIdentifier>>> TryLoadMemento(TIdentifier id);
-        protected abstract Task StoreMemento(Func<Task<KeyValuePair<TIdentifier, AggregateMemento<TIdentifier>>>> mementoFactory);
+        protected abstract Task<Maybe<AggregateMemento>> TryLoadMemento(object id);
+        protected abstract Task StoreMemento(Func<Task<KeyValuePair<object, AggregateMemento>>> mementoFactory);
 
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
+        protected override async Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, int maxVersion)
         {
             return (await TryLoadMemento(id))
                 .Where(x => x.Snapshot.Select(y => y.Version <= maxVersion).ValueOrDefault())
-                .Select(x => new AggregateSnapshotLoadFrame<TIdentifier>(x.AggregateType, id, x.Snapshot.Value))
+                .Select(x => new AggregateSnapshotLoadFrame(x.AggregateType, id, x.Snapshot.Value))
                 .ValueOrDefault();
         }
 
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
+        protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)
         {
             return (await TryLoadMemento(id))
-                .Select(x => new AggregateEventsLoadFrame<TIdentifier>(
-                                 x.AggregateType,
-                                 id,
-                                 x.Events
-                                  .SkipWhile(y => y.Version < minVersion)
-                                  .TakeWhile(y => y.Version <= maxVersion)))
+                .Select(x => new AggregateEventsLoadFrame(
+                    x.AggregateType,
+                    id,
+                    x.Events
+                        .SkipWhile(y => y.Version < minVersion)
+                        .TakeWhile(y => y.Version <= maxVersion)))
                 .ValueOrDefault();
         }
 
-        protected override Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
+        protected override Task SaveSnapshot(AggregateSnapshotSaveFrame frame)
         {
             return StoreMemento(async () =>
             {
@@ -67,32 +65,32 @@ protected override Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> fra
 
                 var state = (await TryLoadMemento(snapshot.Id)).ValueOrDefault();
 
-                return KeyValuePair.Create(snapshot.Id, new AggregateMemento<TIdentifier>(aggregateType, snapshot.ToMaybe(), state != null ? state.Events : null));
+                return KeyValuePair.Create(snapshot.Id, new AggregateMemento(aggregateType, snapshot.ToMaybe(), state != null ? state.Events : null));
             });
         }
 
-        protected override Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
+        protected override Task SaveEvents(AggregateEventsSaveFrame frame)
         {
             var aggregateType = frame.AggregateType;
             var id = frame.Id;
             var events = frame.Events.ToArray();
 
-            return StoreMemento(async () => 
+            return StoreMemento(async () =>
                 KeyValuePair.Create(id, (await TryLoadMemento(id))
                     .Select(x =>
                     {
                         var lastEvent = x.Events.TryLast();
                         var actualVersion = lastEvent.Select(y => y.Version).ValueOrDefault();
 
-                        if(actualVersion != frame.ExpectedVersion)
+                        if (actualVersion != frame.ExpectedVersion)
                             throw new AggregateConcurrencyException();
 
-                        return new AggregateMemento<TIdentifier>(
+                        return new AggregateMemento(
                             aggregateType,
                             x.Snapshot,
                             x.Events.Concat(events.SkipWhile(y => y.Version <= lastEvent.Select(z => z.Version).ValueOrDefault())));
                     })
-                    .ValueOrDefault(() => new AggregateMemento<TIdentifier>(aggregateType, Maybe<IAggregateSnapshot<TIdentifier>>.NoValue, events))));
+                    .ValueOrDefault(() => new AggregateMemento(aggregateType, Maybe<IAggregateSnapshot>.NoValue, events))));
         }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs b/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
index 2356559..f25d1d3 100644
--- a/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
+++ b/src/iSynaptic.Core.Persistence/SqlServerAggregateRepository.cs
@@ -36,7 +36,7 @@
 
 namespace iSynaptic.Core.Persistence
 {
-    public static class SqlServerAggregateRepository
+    public class SqlServerAggregateRepository : AggregateRepository
     {
         private static readonly Regex _scriptRegex = new Regex(@"(?<script>.+?)(\r\nGO(\r\n|$))", 
             RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Singleline);
@@ -68,12 +68,7 @@ public static async Task EnsureTablesExist(string connectionString)
                 }
             }
         }
-    }
 
-    public class SqlServerAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
-        where TAggregate : class, IAggregate<TIdentifier> 
-        where TIdentifier : IEquatable<TIdentifier>
-    {
         #region Helper Classes
 
         private abstract class DbRow
@@ -91,8 +86,8 @@ protected DbRow(string aggregateId, int version, string type)
 
             private string ValidateAggregateId(string value, string argumentName)
             {
-                if(value == null) throw new ArgumentNullException(argumentName);
-                if(value.Length > 200) throw new ArgumentException("Aggregate ID must be 200 characters or less.", argumentName);
+                if (value == null) throw new ArgumentNullException(argumentName);
+                if (value.Length > 200) throw new ArgumentException("Aggregate ID must be 200 characters or less.", argumentName);
 
                 return value;
             }
@@ -122,8 +117,8 @@ public int Version
             {
                 get { return _version; }
                 set { _version = ValidateVersion(value, "value"); }
-            }  
-          
+            }
+
             public string Type
             {
                 get { return _type; }
@@ -143,8 +138,8 @@ protected DbDataRow(string aggregateId, int version, string type, string data)
 
             private string ValidateData(string data, string argumentName)
             {
-                if(data == null) throw new ArgumentNullException(argumentName);
-                if(string.IsNullOrWhiteSpace(data)) throw new ArgumentException("Data cannot be only whitespace.", argumentName);
+                if (data == null) throw new ArgumentNullException(argumentName);
+                if (string.IsNullOrWhiteSpace(data)) throw new ArgumentException("Data cannot be only whitespace.", argumentName);
 
                 return data;
             }
@@ -158,7 +153,7 @@ public string Data
 
         private class DbAggregate : DbRow
         {
-            public DbAggregate(string aggregateId, int version, string type) 
+            public DbAggregate(string aggregateId, int version, string type)
                 : base(aggregateId, version, type)
             {
             }
@@ -174,7 +169,7 @@ public DbAggregateEvent(string aggregateId, int version, string type, string dat
 
         private class DbAggregateSnapshot : DbDataRow
         {
-            public DbAggregateSnapshot(string aggregateId, int version, string type, string data) 
+            public DbAggregateSnapshot(string aggregateId, int version, string type, string data)
                 : base(aggregateId, version, type, data)
             {
             }
@@ -195,7 +190,7 @@ public SqlServerAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, st
             _connectionString = Guard.NotNullOrWhiteSpace(connectionString, "connectionString");
         }
 
-        protected override async Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, int maxVersion)
+        protected override async Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, int maxVersion)
         {
             string idString = ConvertIdentifierToString(id);
 
@@ -229,8 +224,8 @@ ORDER BY Version DESC"
                         {
                             string data = reader.GetString(reader.GetOrdinal("Data"));
 
-                            var snapshot = _dataSerializer.Deserialize<IAggregateSnapshot<TIdentifier>>(data);
-                            return new AggregateSnapshotLoadFrame<TIdentifier>(aggregateType, id, snapshot);
+                            var snapshot = _dataSerializer.Deserialize<IAggregateSnapshot>(data);
+                            return new AggregateSnapshotLoadFrame(aggregateType, id, snapshot);
                         }
                     }
                 }
@@ -239,10 +234,10 @@ ORDER BY Version DESC"
             }
         }
 
-        protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, int minVersion, int maxVersion)
+        protected override async Task<AggregateEventsLoadFrame> GetEvents(object id, int minVersion, int maxVersion)
         {
             string idString = ConvertIdentifierToString(id);
-            
+
             using (var connection = new SqlConnection(_connectionString))
             {
                 await connection.OpenAsync();
@@ -256,11 +251,11 @@ protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(T
                         LogicalType.Parse(dbAggregate.Type));
 
                     var events = dbEvents
-                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent<TIdentifier>>(x))
+                        .Select(x => _dataSerializer.Deserialize<IAggregateEvent>(x))
                         .ToArray();
 
-                    return events.Length > 0 
-                        ? new AggregateEventsLoadFrame<TIdentifier>(aggregateType, id, events) 
+                    return events.Length > 0
+                        ? new AggregateEventsLoadFrame(aggregateType, id, events)
                         : null;
                 }
 
@@ -268,7 +263,7 @@ protected override async Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(T
             }
         }
 
-        protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame)
+        protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame frame)
         {
             string idString = ConvertIdentifierToString(frame.Id);
             string type = _logicalTypeRegistry.LookupLogicalType(frame.Snapshot.GetType()).ToString();
@@ -313,7 +308,7 @@ protected override async Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifie
             }
         }
 
-        protected override async Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame)
+        protected override async Task SaveEvents(AggregateEventsSaveFrame frame)
         {
             string idString = ConvertIdentifierToString(frame.Id);
             string type = _logicalTypeRegistry.LookupLogicalType(frame.AggregateType).ToString();
@@ -364,8 +359,7 @@ private static async Task UpsertAggregate(SqlConnection connection, SqlTransacti
             }
         }
 
-        private static async Task InsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString,
-                                                  int newVersion, string type)
+        private static async Task InsertAggregate(SqlConnection connection, SqlTransaction transaction, string idString, int newVersion, string type)
         {
             var insertCommand = new SqlCommand
             {
@@ -385,7 +379,7 @@ private static async Task InsertAggregate(SqlConnection connection, SqlTransacti
                 throw new AggregateConcurrencyException();
         }
 
-        private async Task InsertEvents(IEnumerable<IAggregateEvent<TIdentifier>> events, string idString, SqlConnection connection, SqlTransaction transaction)
+        private async Task InsertEvents(IEnumerable<IAggregateEvent> events, string idString, SqlConnection connection, SqlTransaction transaction)
         {
             var dbEvents = events.Select(x => new DbAggregateEvent(idString,
                                                                    x.Version,
@@ -474,10 +468,20 @@ FROM AggregateEvents
             return results.ToArray();
         }
 
-        protected virtual string ConvertIdentifierToString(TIdentifier id)
+        protected virtual string ConvertIdentifierToString(object id)
         {
             Guard.NotNull(id, "id");
             return _dataSerializer.Serialize(id);
         }
     }
-}
+
+    public class SqlServerAggregateRepository<TAggregate, TIdentifier> : AggregateRepository<TAggregate, TIdentifier>
+        where TAggregate : class, IAggregate<TIdentifier>
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        public SqlServerAggregateRepository(ILogicalTypeRegistry logicalTypeRegistry, string connectionString)
+            :base(new SqlServerAggregateRepository(logicalTypeRegistry, connectionString))
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs b/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
index 761370f..ab9cd3f 100644
--- a/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
+++ b/src/iSynaptic.Core.UnitTests/LogicalTypeRegistryBuilder.cs
@@ -40,8 +40,7 @@ public static LogicalTypeRegistry Build()
 
             registry.AddMapping(new LogicalType("tst", "ServiceCaseId"), typeof(ServiceCaseId));
 
-            registry.AddMapping(new LogicalType("tst", "AggregateMemento.ServiceCaseId"), typeof(AggregateMemento<ServiceCaseId>));
-            registry.AddMapping(new LogicalType("tst", "AggregateMemento.RoleIdentifier"), typeof(AggregateMemento<RoleIdentifier>));
+            registry.AddMapping(new LogicalType("tst", "AggregateMemento"), typeof(AggregateMemento));
 
             registry.AddMapping(new LogicalType("tst", "CustomerRoleIdentifier"), typeof(CustomerRoleIdentifier));
             registry.AddMapping(new LogicalType("tst", "CustomerServiceRepresentativeRoleIdentifier"), typeof(CustomerServiceRepresentativeRoleIdentifier));
diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs
index ae5baa9..c204bb3 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateMementoTests.cs
@@ -53,7 +53,7 @@ public void Class_IsJsonSerializable()
                 ServiceCase.SampleContent.CommunicationDuration,
                 ServiceCase.SampleContent.ResponsibleParty);
 
-            var memento = new AggregateMemento<ServiceCaseId>(
+            var memento = new AggregateMemento(
                 typeof (ServiceCase),
                 serviceCase.TakeSnapshot().ToMaybe(),
                 serviceCase.GetEvents());
@@ -61,7 +61,7 @@ public void Class_IsJsonSerializable()
             var serializer = JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build());
 
             String json = serializer.Serialize(memento);
-            var reconstituted = serializer.Deserialize<AggregateMemento<ServiceCaseId>>(json);
+            var reconstituted = serializer.Deserialize<AggregateMemento>(json);
 
             reconstituted.Should().NotBeNull();
             reconstituted.Should().NotBeSameAs(memento);
diff --git a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
index 6b9809f..c25d4a8 100644
--- a/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Modeling/Domain/AggregateRepositoryTests.cs
@@ -9,6 +9,244 @@
 namespace iSynaptic.Modeling.Domain
 {
     public abstract class AggregateRepositoryTests
+    {
+        protected IAggregateRepository Repo { get; set; }
+
+        [Test, ExpectedExceptionAttribute(typeof (ArgumentException))]
+        public async Task Get_InvalidAggregateType_Throws()
+        {
+            await Repo.Get(typeof (string), 1);
+        }
+
+        [Test]
+        public async Task SaveEvents_NewAggregate()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            var events = ((IAggregate)serviceCase).GetEvents();
+
+            await Repo.SaveEvents(typeof(ServiceCase), serviceCase.Id, events);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(1);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase)reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task SaveEvents_ExistingAggregate()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(serviceCase);
+
+            var thread = serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic, ServiceCase.SampleContent.TopicDescription, ServiceCase.SampleContent.ResponsibleParty);
+            var events = ((IAggregate)serviceCase).GetUncommittedEvents().ToArray();
+            events.Length.Should().Be(1);
+
+            await Repo.SaveEvents(typeof(ServiceCase), serviceCase.Id, events);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(2);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+        }
+
+        [Test]
+        public async Task RoundTrip()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(1);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase)reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+
+            var thread = serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic, ServiceCase.SampleContent.TopicDescription, ServiceCase.SampleContent.ResponsibleParty);
+            thread.RecordCommunication(CommunicationDirection.Incoming, ServiceCase.SampleContent.CommunicationContent, SystemClock.UtcNow, ServiceCase.SampleContent.CommunicationDuration, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(3);
+            var events = reconsituted.GetEvents().ToArray();
+
+            var commRecordedEvent = events[2] as ServiceCase.CommunicationRecorded;
+            commRecordedEvent.Should().NotBeNull();
+            commRecordedEvent.Direction.Should().Be(CommunicationDirection.Incoming);
+            commRecordedEvent.Content.Should().Be(ServiceCase.SampleContent.CommunicationContent);
+            commRecordedEvent.Duration.Should().Be(ServiceCase.SampleContent.CommunicationDuration);
+        }
+
+        [Test]
+        public async Task RoundTrip_UsingSnapshot()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(0);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase) reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task RoundTrip_WithChangeAfterSnapshot()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(1);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase) reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task RoundTrip_WithMultipleSnapshots()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            var thread = serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                              ServiceCase.SampleContent.TopicDescription,
+                                                              ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            thread.RecordCommunication(CommunicationDirection.Incoming, ServiceCase.SampleContent.CommunicationContent, SystemClock.UtcNow, ServiceCase.SampleContent.CommunicationDuration, ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+
+            var reconsituted = await Repo.Get(typeof(ServiceCase), serviceCase.Id);
+            reconsituted.Should().NotBeNull();
+            reconsituted.Should().NotBeSameAs(serviceCase);
+
+            reconsituted.GetEvents().Count().Should().Be(0);
+            reconsituted.Id.Should().Be(serviceCase.Id);
+            reconsituted.Version.Should().Be(serviceCase.Version);
+            var reconsitutedServiceCase = (ServiceCase) reconsituted;
+            reconsitutedServiceCase.Title.Should().Be(serviceCase.Title);
+            reconsitutedServiceCase.Description.Should().Be(serviceCase.Description);
+            reconsitutedServiceCase.Priority.Should().Be(serviceCase.Priority);
+        }
+
+        [Test]
+        public async Task TakingSnapshot_ForSameVersion_IsOkay()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+            await Repo.SaveSnapshot(serviceCase);
+        }
+
+        [Test]
+        public async Task ConcurrecyConflict_WithTrueConflict_ThrowsException()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            var winner = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+            var loser = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+
+            winner.StartCommunicationThread("Win", "Winning", ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(winner);
+
+            loser.StartCommunicationThread("Lose", "Loosing", ServiceCase.SampleContent.ResponsibleParty);
+
+            try
+            {
+                await Repo.Save(loser);
+                Assert.Fail("Exception was not thrown");
+            }
+            catch (AggregateConcurrencyException)
+            {
+            }
+        }
+
+        [Test]
+        public async Task ConcurrencyConflict_WithFalseConflict_ResolvesConflict()
+        {
+            var serviceCase = new ServiceCase(ServiceCase.SampleContent.Title, ServiceCase.SampleContent.Description, ServiceCasePriority.Normal, ServiceCase.SampleContent.ResponsibleParty);
+            serviceCase.StartCommunicationThread(ServiceCase.SampleContent.Topic,
+                                                 ServiceCase.SampleContent.TopicDescription,
+                                                 ServiceCase.SampleContent.ResponsibleParty);
+
+            await Repo.Save(serviceCase);
+
+            var winner = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+            var secondWinner = (ServiceCase)await Repo.Get(typeof(ServiceCase), serviceCase.Id, Int32.MaxValue);
+
+            winner.StartCommunicationThread("Win", "Winning", ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(winner);
+
+            secondWinner.Threads.First().RecordCommunication(CommunicationDirection.Outgoing, "Also Win", SystemClock.UtcNow, ServiceCase.SampleContent.CommunicationDuration, ServiceCase.SampleContent.ResponsibleParty);
+            await Repo.Save(secondWinner);
+
+            secondWinner.Version.Should().Be(4);
+            var events = secondWinner.GetEvents().ToArray();
+
+            events[2].Should().BeOfType<ServiceCase.CommunicationThreadStarted>();
+            events[3].Should().BeOfType<ServiceCase.CommunicationRecorded>();
+
+            var cre = (ServiceCase.CommunicationRecorded)events[3];
+            cre.Version.Should().Be(4);
+            cre.Direction.Should().Be(CommunicationDirection.Outgoing);
+            cre.Content.Should().Be("Also Win");
+        }
+    }
+
+    public abstract class GenericAggregateRepositoryTests
     {
         protected IAggregateRepository<ServiceCase, ServiceCaseId> Repo { get; set; }
 
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
index 037fd42..c2c7cdf 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/EventStoreAggregateRepositoryTests.cs
@@ -20,14 +20,12 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using System;
 using System.Net;
 using EventStore.ClientAPI;
-using NUnit.Framework;
 using iSynaptic.Core.Persistence;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
@@ -39,7 +37,19 @@ public EventStoreAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
+            Repo = new EventStoreAggregateRepository(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113)));
+        }
+    }
+
+    [TestFixture]
+    [Explicit("Integration tests - requires EventStore to be running locally.")]
+    public class EventStoreGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
+    {
+        public EventStoreGenericAggregateRepositoryTests()
+        {
+            var ltr = LogicalTypeRegistryBuilder.Build();
+
             Repo = new EventStoreAggregateRepository<ServiceCase, ServiceCaseId>(ltr, () => EventStoreConnection.Create(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113)));
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
index ef949e9..0d64170 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryAggregateRepositoryTests.cs
@@ -20,12 +20,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using System;
-using NUnit.Framework;
 using iSynaptic.Core.Persistence;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
@@ -33,8 +31,17 @@ namespace iSynaptic.Persistence
     public class InMemoryAggregateRepositoryTests : AggregateRepositoryTests
     {
         public InMemoryAggregateRepositoryTests()
+        {
+            Repo = new InMemoryAggregateRepository();
+        }
+    }
+
+    [TestFixture]
+    public class InMemoryGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
+    {
+        public InMemoryGenericAggregateRepositoryTests()
         {
             Repo = new InMemoryAggregateRepository<ServiceCase, ServiceCaseId>();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
index e6ff18c..e1b5b61 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/InMemoryJsonAggregateRepositoryTests.cs
@@ -1,10 +1,30 @@
-using System;
-using NUnit.Framework;
+// The MIT License
+// 
+// Copyright (c) 2013 Jordan E. Terrell
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
 using iSynaptic.Core.Persistence;
-using iSynaptic.Modeling;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.Serialization;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
@@ -12,6 +32,15 @@ namespace iSynaptic.Persistence
     public class InMemoryJsonAggregateRepositoryTests : AggregateRepositoryTests
     {
         public InMemoryJsonAggregateRepositoryTests()
+        {
+            Repo = new InMemoryJsonAggregateRepository(JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build()));
+        }
+    }
+
+    [TestFixture]
+    public class InMemoryJsonGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
+    {
+        public InMemoryJsonGenericAggregateRepositoryTests()
         {
             Repo = new InMemoryJsonAggregateRepository<ServiceCase, ServiceCaseId>(
                 JsonSerializerBuilder.Build(LogicalTypeRegistryBuilder.Build()));
diff --git a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
index 3571364..653d560 100644
--- a/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
+++ b/src/iSynaptic.Core.UnitTests/Persistence/SqlServerAggregateRepositoryTests.cs
@@ -20,12 +20,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-using System;
-using System.Threading.Tasks;
-using NUnit.Framework;
 using iSynaptic.Core.Persistence;
 using iSynaptic.Modeling.Domain;
 using iSynaptic.TestDomain;
+using NUnit.Framework;
 
 namespace iSynaptic.Persistence
 {
@@ -39,6 +37,26 @@ public SqlServerAggregateRepositoryTests()
         {
             var ltr = LogicalTypeRegistryBuilder.Build();
 
+            Repo = new SqlServerAggregateRepository(ltr, ConnectionString);
+        }
+
+        [TestFixtureSetUp]
+        public void FixtureSetup()
+        {
+            SqlServerAggregateRepository.EnsureTablesExist(ConnectionString).Wait();
+        }
+    }
+
+    [TestFixture]
+    [Explicit("Integration tests - requires Sql Server to be running locally.")]
+    public class SqlServerGenericAggregateRepositoryTests : GenericAggregateRepositoryTests
+    {
+        private const string ConnectionString = "Data Source=(local);Initial Catalog=AggregateStore;Integrated Security=true;";
+
+        public SqlServerGenericAggregateRepositoryTests()
+        {
+            var ltr = LogicalTypeRegistryBuilder.Build();
+
             Repo = new SqlServerAggregateRepository<ServiceCase, ServiceCaseId>(ltr, ConnectionString);
         }
 
@@ -48,4 +66,4 @@ public void FixtureSetup()
             SqlServerAggregateRepository.EnsureTablesExist(ConnectionString).Wait();
         }
     }
-}
+}
\ No newline at end of file
diff --git a/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs b/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs
index 7ea9047..44fb545 100644
--- a/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs
+++ b/src/iSynaptic.Core.UnitTests/TestDomain/Generated.cs
@@ -227,7 +227,7 @@ public CommunicationRecorded(Int32 threadId, CommunicationDirection direction, S
             [GeneratedCode("iSynaptic.Core", "0.1.23.0")]
             public TimeSpan Duration { get { return _duration; } }
         }
-        public class Snapshot : AggregateSnapshot<ServiceCaseId>
+        public class Snapshot : AggregateSnapshot
         {
             private readonly Int32 _lastThreadId;
             private readonly IEnumerable<CommunicationThreadSnapshot> _threadSnapshots;
diff --git a/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs b/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs
index 1659205..b2f712c 100644
--- a/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs
+++ b/src/iSynaptic.Core.UnitTests/TestDomain/ServiceCase.cs
@@ -84,7 +84,7 @@ protected override void OnInitialize()
             _threads = new List<CommunicationThread>();
         }
 
-        public override IAggregateSnapshot<ServiceCaseId> TakeSnapshot()
+        public override IAggregateSnapshot TakeSnapshot()
         {
             return new Snapshot(_lastThreadId,
                                 _threads.Select(x => new CommunicationThreadSnapshot(x.ThreadId, x.Topic, x.Description)),
diff --git a/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs b/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
index 73054d5..a2eeb44 100644
--- a/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/Aggregate.cs
@@ -29,15 +29,11 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    internal interface IAggregateInternal<out TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    internal interface IAggregateInternal
     {
-        void Initialize(IAggregateMemento memento);
-
+        void Initialize(AggregateMemento memento);
         void ApplyEvents(IEnumerable<IAggregateEvent> events);
-
         Boolean ConflictsWith(IEnumerable<IAggregateEvent> committedEvents, IEnumerable<IAggregateEvent> attemptedEvents);
-
         void CommitEvents();
     }
 
@@ -54,7 +50,7 @@ public static void FieldsImmuneToReset(Func<FieldInfo, bool> predicate)
         internal static Func<FieldInfo, bool> FieldResetImmunityPredicate { get { return _fieldResetImmunityPredicate; }}
     }
 
-    public abstract class Aggregate<TIdentifier> : IAggregate<TIdentifier>, IAggregateInternal<TIdentifier>
+    public abstract class Aggregate<TIdentifier> : IAggregate<TIdentifier>, IAggregateInternal, IAggregate
         where TIdentifier : IEquatable<TIdentifier>
     {
         [ImmuneToReset]
@@ -67,14 +63,14 @@ public abstract class Aggregate<TIdentifier> : IAggregate<TIdentifier>, IAggrega
         private Action<IAggregate<TIdentifier>, IAggregateEvent<TIdentifier>> _eventDispatcher;
 
         [ImmuneToReset]
-        private Action<IAggregate<TIdentifier>, IAggregateSnapshot<TIdentifier>> _snapshotDispatcher;
+        private Action<IAggregate<TIdentifier>, IAggregateSnapshot> _snapshotDispatcher;
 
         protected Aggregate()
         {
             Initialize(null);
         }
 
-        private void Initialize(IAggregateMemento memento)
+        private void Initialize(AggregateMemento memento)
         {
             _events = new AggregateEventStream<TIdentifier>();
 
@@ -86,24 +82,24 @@ private void Initialize(IAggregateMemento memento)
 
             if (memento != null)
             {
-                var m = memento.ToMemento<TIdentifier>();
+                var m = memento;
 
                 if (m.Snapshot.HasValue)
                     ApplySnapshot(m.Snapshot.Value);
 
-                ApplyEventsCore(m.Events);
+                ApplyEventsCore(m.Events.Cast<IAggregateEvent<TIdentifier>>());
                 _events.CommitEvents();
             }
         }
 
-        void IAggregateInternal<TIdentifier>.Initialize(IAggregateMemento memento)
+        void IAggregateInternal.Initialize(AggregateMemento memento)
         {
-            Initialize(memento.ToMemento<TIdentifier>());
+            Initialize(memento);
         }
 
-        private void ApplySnapshot(IAggregateSnapshot<TIdentifier> snapshot)
+        private void ApplySnapshot(IAggregateSnapshot snapshot)
         {
-            Id = snapshot.Id;
+            Id = (TIdentifier)snapshot.Id;
             Version = snapshot.Version;
 
             DispatchSnapshot(snapshot);
@@ -127,7 +123,7 @@ protected void ApplyEvent(IAggregateEvent<TIdentifier> @event)
             ApplyEventsCore(new[] { @event });
         }
 
-        void IAggregateInternal<TIdentifier>.ApplyEvents(IEnumerable<IAggregateEvent> events)
+        void IAggregateInternal.ApplyEvents(IEnumerable<IAggregateEvent> events)
         {
             ApplyEventsCore(events.Cast<IAggregateEvent<TIdentifier>>());
         }
@@ -157,7 +153,7 @@ protected virtual void DispatchEvent(IAggregateEvent<TIdentifier> @event)
             _eventDispatcher(this, @event);
         }
 
-        protected virtual void DispatchSnapshot(IAggregateSnapshot<TIdentifier> snapshot)
+        protected virtual void DispatchSnapshot(IAggregateSnapshot snapshot)
         {
             if(_snapshotDispatcher == null)
                 _snapshotDispatcher = AggregateHelper.GetSnapshotDispatcher<TIdentifier>(GetType());
@@ -166,7 +162,7 @@ protected virtual void DispatchSnapshot(IAggregateSnapshot<TIdentifier> snapshot
         }
 
         protected virtual void OnInitialize() { }
-        public virtual IAggregateSnapshot<TIdentifier> TakeSnapshot() { return null; }
+        public virtual IAggregateSnapshot TakeSnapshot() { return null; }
         public IEnumerable<IAggregateEvent<TIdentifier>> GetEvents() { return _events.Events; }
             
         public IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents()
@@ -174,12 +170,12 @@ public IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents()
             return _events.UncommittedEvents;
         }
 
-        void IAggregateInternal<TIdentifier>.CommitEvents()
+        void IAggregateInternal.CommitEvents()
         {
             _events.CommitEvents();
         }
 
-        Boolean IAggregateInternal<TIdentifier>.ConflictsWith(IEnumerable<IAggregateEvent> committedEvents,
+        Boolean IAggregateInternal.ConflictsWith(IEnumerable<IAggregateEvent> committedEvents,
                                                               IEnumerable<IAggregateEvent> attemptedEvents)
         {
             return ConflictsWith(committedEvents.Cast<IAggregateEvent<TIdentifier>>(),
@@ -196,8 +192,25 @@ from attemptedEvent in attemptedEvents
         }
 
         protected internal virtual Boolean ConflictsWith(IAggregateEvent<TIdentifier> committedEvent, IAggregateEvent<TIdentifier> attemptedEvent) { return true; }
-        
+
         public TIdentifier Id { get; private set; }
         public Int32 Version { get; private set; }
+
+        object IAggregate.Id { get { return Id; } }
+
+        IEnumerable<IAggregateEvent> IAggregate.GetUncommittedEvents()
+        {
+            return GetUncommittedEvents();
+        }
+
+        IEnumerable<IAggregateEvent> IAggregate.GetEvents()
+        {
+            return GetEvents();
+        }
+
+        IAggregateSnapshot IAggregate.TakeSnapshot()
+        {
+            return TakeSnapshot();
+        }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
index b8b5607..25efbc6 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsLoadFrame.cs
@@ -26,15 +26,14 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public class AggregateEventsLoadFrame<TIdentifier> : AggregateLoadFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class AggregateEventsLoadFrame : AggregateLoadFrame
     {
-        public AggregateEventsLoadFrame(Type aggregateType, TIdentifier id, IEnumerable<IAggregateEvent<TIdentifier>> events)
+        public AggregateEventsLoadFrame(Type aggregateType, object id, IEnumerable<IAggregateEvent> events)
             : base(aggregateType, id)
         {
             Events = Guard.NotNull(events, "events");
         }
 
-        public IEnumerable<IAggregateEvent<TIdentifier>> Events { get; private set; }
+        public IEnumerable<IAggregateEvent> Events { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
index 4425a8b..3f94b29 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateEventsSaveFrame.cs
@@ -26,11 +26,10 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public class AggregateEventsSaveFrame<TIdentifier> : AggregateSaveFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class AggregateEventsSaveFrame : AggregateSaveFrame
     {
-        public AggregateEventsSaveFrame(Type aggregateType, TIdentifier id, Boolean isNew, Int32 expectedVersion, Int32 newVersion, IEnumerable<IAggregateEvent<TIdentifier>> events)
-            : base (aggregateType, id, isNew)
+        public AggregateEventsSaveFrame(Type aggregateType, object id, Boolean isNew, Int32 expectedVersion, Int32 newVersion, IEnumerable<IAggregateEvent> events)
+            : base(aggregateType, id, isNew)
         {
             ExpectedVersion = expectedVersion;
             NewVersion = newVersion;
@@ -39,6 +38,6 @@ public AggregateEventsSaveFrame(Type aggregateType, TIdentifier id, Boolean isNe
 
         public Int32 ExpectedVersion { get; private set; }
         public Int32 NewVersion { get; private set; }
-        public IEnumerable<IAggregateEvent<TIdentifier>> Events { get; private set; }
+        public IEnumerable<IAggregateEvent> Events { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs
index cd36ed9..e515f2a 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateHelper.cs
@@ -51,10 +51,10 @@ public static Action<IAggregate<TIdentifier>, IAggregateEvent<TIdentifier>> GetE
             return GetDispatcher<IAggregateEvent<TIdentifier>, TIdentifier>(aggregateType, "On", _eventDispatchers);
         }
 
-        public static Action<IAggregate<TIdentifier>, IAggregateSnapshot<TIdentifier>> GetSnapshotDispatcher<TIdentifier>(Type aggregateType)
+        public static Action<IAggregate<TIdentifier>, IAggregateSnapshot> GetSnapshotDispatcher<TIdentifier>(Type aggregateType)
             where TIdentifier : IEquatable<TIdentifier>
         {
-            return GetDispatcher<IAggregateSnapshot<TIdentifier>, TIdentifier>(aggregateType, "Apply", _snapshotDispatchers);
+            return GetDispatcher<IAggregateSnapshot, TIdentifier>(aggregateType, "Apply", _snapshotDispatchers);
         }
 
         private static Action<IAggregate<TIdentifier>, T> GetDispatcher<T, TIdentifier>(Type aggregateType, String methodName, ConcurrentDictionary<Type, Delegate> dictionary)
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs
index eba632b..7e6fb0f 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateLoadFrame.cs
@@ -25,6 +25,18 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public abstract class AggregateLoadFrame
+    {
+        protected AggregateLoadFrame(Type aggregateType, object id)
+        {
+            AggregateType = Guard.NotNull(aggregateType, "aggregateType");
+            Id = id;
+        }
+
+        public Type AggregateType { get; private set; }
+        public object Id { get; private set; }
+    }
+
     public abstract class AggregateLoadFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
index eafe4f4..29733b6 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateMemento.cs
@@ -27,28 +27,17 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public sealed class AggregateMemento<TIdentifier> : IAggregateMemento
-        where TIdentifier : IEquatable<TIdentifier>
+    public sealed class AggregateMemento
     {
-        public AggregateMemento(Type aggregateType, Maybe<IAggregateSnapshot<TIdentifier>> snapshot, IEnumerable<IAggregateEvent<TIdentifier>> events)
+        public AggregateMemento(Type aggregateType, Maybe<IAggregateSnapshot> snapshot, IEnumerable<IAggregateEvent> events)
         {
             AggregateType = Guard.NotNull(aggregateType, "aggregateType");
             Snapshot = snapshot;
-            Events = events ?? Enumerable.Empty<IAggregateEvent<TIdentifier>>();
-        }
-
-        AggregateMemento<TDesiredIdentifier> IAggregateMemento.ToMemento<TDesiredIdentifier>()
-        {
-            var m = this as AggregateMemento<TDesiredIdentifier>;
-
-            return m ?? new AggregateMemento<TDesiredIdentifier>(AggregateType,
-                Snapshot.Cast<IAggregateSnapshot<TDesiredIdentifier>>(),
-                Events.Cast<IAggregateEvent<TDesiredIdentifier>>()
-            );
+            Events = events ?? Enumerable.Empty<IAggregateEvent>();
         }
 
         public Type AggregateType { get; private set; }
-        public Maybe<IAggregateSnapshot<TIdentifier>> Snapshot { get; private set; }
-        public IEnumerable<IAggregateEvent<TIdentifier>> Events { get; private set; }
+        public Maybe<IAggregateSnapshot> Snapshot { get; private set; }
+        public IEnumerable<IAggregateEvent> Events { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
index de08cc9..16a8229 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateRepository.cs
@@ -1,4 +1,4 @@
-// The MIT License
+// The MT License
 // 
 // Copyright (c) 2013 Jordan E. Terrell
 // 
@@ -26,36 +26,38 @@
 using System.Runtime.Serialization;
 using System.Threading.Tasks;
 using iSynaptic.Commons;
+using iSynaptic.Commons.Reflection;
 using iSynaptic.Commons.Threading.Tasks;
 
 namespace iSynaptic.Modeling.Domain
 {
-    public abstract class AggregateRepository<TAggregate, TIdentifier> : IAggregateRepository<TAggregate, TIdentifier> 
-        where TAggregate : class, IAggregate<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public abstract class AggregateRepository : IAggregateRepository, IAggregateRepositoryInternal
     {
         private static readonly Task _completedTask = Task.FromResult(true);
 
-        ITask<TAggregate> IAggregateRepositoryQueries<TAggregate, TIdentifier>.Get(TIdentifier id, Int32 maxVersion)
+        public async Task<IAggregate> Get(Type aggregateType, object id, int maxVersion = int.MaxValue)
         {
-            return Get(id, maxVersion).ToCovariantTask();
+            if (!aggregateType.DoesImplementType(typeof(IAggregate)))
+                throw new ArgumentException("AggregateType must implement IAggregate.");
+
+            return await ((IAggregateRepositoryInternal)this).GetCore<IAggregate>(aggregateType, id, maxVersion);
         }
 
-        public async Task<TAggregate> Get(TIdentifier id, Int32 maxVersion)
+        async Task<T> IAggregateRepositoryInternal.GetCore<T>(Type aggregateType, object id, int maxVersion)
         {
             var memento = await GetMemento(id, maxVersion);
 
             if (memento == null)
                 return null;
 
-            var aggregate = (TAggregate)FormatterServices.GetSafeUninitializedObject(memento.AggregateType);
+            var aggregate = (IAggregate) FormatterServices.GetSafeUninitializedObject(memento.AggregateType);
             var ag = AsInternal(aggregate);
             ag.Initialize(memento);
 
-            return aggregate;
+            return (T)aggregate;
         }
 
-        public async Task Save(TAggregate aggregate)
+        public async Task Save(IAggregate aggregate)
         {
             Guard.NotNull(aggregate, "aggregate");
 
@@ -69,9 +71,9 @@ public async Task Save(TAggregate aggregate)
             var firstEvent = events[0];
 
             int saveAttempts = 0;
-            while(true)
+            while (true)
             {
-                var data = new AggregateEventsSaveFrame<TIdentifier>(aggregateType, aggregate.Id, firstEvent.Version == 1, firstEvent.Version - 1, aggregate.Version, events);
+                var data = new AggregateEventsSaveFrame(aggregateType, aggregate.Id, firstEvent.Version == 1, firstEvent.Version - 1, aggregate.Version, events);
 
                 AggregateConcurrencyException originalException;
                 try
@@ -88,7 +90,7 @@ public async Task Save(TAggregate aggregate)
 
                     originalException = ace;
                 }
-                
+
                 var committedEvents = await GetEvents(aggregate.Id, events[0].Version, Int32.MaxValue);
                 if (ag.ConflictsWith(committedEvents.Events, events))
                 {
@@ -111,7 +113,7 @@ public async Task Save(TAggregate aggregate)
             await OnEventStreamSaved(aggregateType, aggregate.Id, events);
         }
 
-        public async Task SaveSnapshot(TAggregate aggregate)
+        public async Task SaveSnapshot(IAggregate aggregate)
         {
             Guard.NotNull(aggregate, "aggregate");
 
@@ -125,53 +127,110 @@ public async Task SaveSnapshot(TAggregate aggregate)
             var events = aggregate.GetUncommittedEvents().ToArray();
             bool isNew = events.Length > 0 && events[0].Version == 1;
 
-            var data = new AggregateSnapshotSaveFrame<TIdentifier>(aggregateType, aggregate.Id, isNew, snapshot);
+            var data = new AggregateSnapshotSaveFrame(aggregateType, aggregate.Id, isNew, snapshot);
             await SaveSnapshot(data);
 
             await OnSnapshotSaved(aggregateType, snapshot);
         }
 
-        private IAggregateInternal<TIdentifier> AsInternal(TAggregate aggregate)
+        public async Task SaveEvents(Type aggregateType, object id, IEnumerable<IAggregateEvent> events)
+        {
+            Guard.NotNull(aggregateType, "aggregateType");
+            Guard.NotNull(id, "id");
+            Guard.NotNull(events, "events");
+
+            var eventsToSave = events as IAggregateEvent[] ?? events.ToArray();
+            if (eventsToSave.Length <= 0)
+                return;
+
+            var firstEvent = eventsToSave[0];
+            var data = new AggregateEventsSaveFrame(aggregateType, id, firstEvent.Version == 1, firstEvent.Version - 1, firstEvent.Version + eventsToSave.Length, eventsToSave);
+
+            await SaveEvents(data);
+            await OnEventStreamSaved(aggregateType, id, eventsToSave);
+        }
+
+        private IAggregateInternal AsInternal(IAggregate aggregate)
         {
-            var ag = aggregate as IAggregateInternal<TIdentifier>;
-            if(ag == null) throw new InvalidOperationException("Aggregate must inherit from Aggregate<TIdentifier>.");
+            var ag = aggregate as IAggregateInternal;
+            if (ag == null) throw new InvalidOperationException("Aggregate must implement IAggregate.");
             return ag;
         }
 
-        protected virtual Task OnEventStreamSaved(Type aggregateType, TIdentifier id, IEnumerable<IAggregateEvent<TIdentifier>> events) { return _completedTask; }
-        protected virtual Task OnSnapshotSaved(Type aggregateType, IAggregateSnapshot<TIdentifier> snapshot) { return _completedTask; }
+        protected virtual Task OnEventStreamSaved(Type aggregateType, object id, IEnumerable<IAggregateEvent> events) { return _completedTask; }
+        protected virtual Task OnSnapshotSaved(Type aggregateType, IAggregateSnapshot snapshot) { return _completedTask; }
 
-        public async Task<AggregateMemento<TIdentifier>> GetMemento(TIdentifier id, Int32 maxVersion)
+        public async Task<AggregateMemento> GetMemento(object id, Int32 maxVersion)
         {
             var snapshotFrame = await GetSnapshot(id, maxVersion);
             if (snapshotFrame != null)
             {
                 var snapshot = snapshotFrame.Snapshot;
-                var events = Enumerable.Empty<IAggregateEvent<TIdentifier>>();
-                
+                var events = Enumerable.Empty<IAggregateEvent>();
+
                 if (snapshot.Version < maxVersion)
                 {
                     var eventsFrame = await GetEvents(id, snapshot.Version + 1, maxVersion);
-                    if(eventsFrame != null)
+                    if (eventsFrame != null)
                         events = eventsFrame.Events;
                 }
 
-                return new AggregateMemento<TIdentifier>(snapshotFrame.AggregateType, snapshot.ToMaybe(), events);
+                return new AggregateMemento(snapshotFrame.AggregateType, snapshot.ToMaybe(), events);
             }
             else
             {
                 var eventsFrame = await GetEvents(id, 1, maxVersion);
 
-                return eventsFrame != null 
-                    ? new AggregateMemento<TIdentifier>(eventsFrame.AggregateType, Maybe.NoValue, eventsFrame.Events)
+                return eventsFrame != null
+                    ? new AggregateMemento(eventsFrame.AggregateType, Maybe.NoValue, eventsFrame.Events)
                     : null;
             }
         }
 
-        protected abstract Task<AggregateSnapshotLoadFrame<TIdentifier>> GetSnapshot(TIdentifier id, Int32 maxVersion);
-        protected abstract Task<AggregateEventsLoadFrame<TIdentifier>> GetEvents(TIdentifier id, Int32 minVersion, Int32 maxVersion);
+        protected abstract Task<AggregateSnapshotLoadFrame> GetSnapshot(object id, Int32 maxVersion);
+        protected abstract Task<AggregateEventsLoadFrame> GetEvents(object id, Int32 minVersion, Int32 maxVersion);
+
+        protected abstract Task SaveSnapshot(AggregateSnapshotSaveFrame frame);
+        protected abstract Task SaveEvents(AggregateEventsSaveFrame frame);
+    }
 
-        protected abstract Task SaveSnapshot(AggregateSnapshotSaveFrame<TIdentifier> frame);
-        protected abstract Task SaveEvents(AggregateEventsSaveFrame<TIdentifier> frame);
+    internal interface IAggregateRepositoryInternal
+    {
+        Task<T> GetCore<T>(Type aggregateId, object id, Int32 maxVersion)
+            where T : class, IAggregate;
+    }
+
+    public abstract class AggregateRepository<TAggregate, TIdentifier> : IAggregateRepository<TAggregate, TIdentifier> 
+        where TAggregate : class, IAggregate<TIdentifier>
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        private readonly IAggregateRepository _innerRepository;
+        private readonly IAggregateRepositoryInternal _internalRepository;
+
+        protected AggregateRepository(IAggregateRepository innerRepository)
+        {
+            _innerRepository = Guard.NotNull(innerRepository, "innerRepository");
+            _internalRepository = innerRepository as IAggregateRepositoryInternal;
+
+            if (_internalRepository == null)
+            {
+                throw new ArgumentException("Inner IAggregateRepository must implement AggregateRepository.");
+            }
+        }
+
+        ITask<TAggregate> IAggregateRepositoryQueries<TAggregate, TIdentifier>.Get(TIdentifier id, Int32 maxVersion)
+        {
+            return _internalRepository.GetCore<TAggregate>(typeof (TAggregate), id, maxVersion).ToCovariantTask();
+        }
+
+        Task IAggregateRepositoryCommands<TAggregate, TIdentifier>.Save(TAggregate aggregate)
+        {
+            return _innerRepository.Save(aggregate);
+        }
+
+        Task IAggregateRepositoryCommands<TAggregate, TIdentifier>.SaveSnapshot(TAggregate aggregate)
+        {
+            return _innerRepository.SaveSnapshot(aggregate);
+        }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs
index 86100d5..9d334fa 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSaveFrame.cs
@@ -25,6 +25,20 @@
 
 namespace iSynaptic.Modeling.Domain
 {
+    public abstract class AggregateSaveFrame
+    {
+        protected AggregateSaveFrame(Type aggregateType, object id, Boolean isNew)
+        {
+            AggregateType = Guard.NotNull(aggregateType, "aggregateType");
+            Id = id;
+            IsNew = isNew;
+        }
+
+        public Type AggregateType { get; private set; }
+        public object Id { get; private set; }
+        public Boolean IsNew { get; private set; }
+    }
+
     public abstract class AggregateSaveFrame<TIdentifier>
         where TIdentifier : IEquatable<TIdentifier>
     {
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
index 2870d5b..04cd900 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshot.cs
@@ -25,10 +25,9 @@
 namespace iSynaptic.Modeling.Domain
 {
     [Serializable]
-    public abstract class AggregateSnapshot<TIdentifier> : IAggregateSnapshot<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public abstract class AggregateSnapshot : IAggregateSnapshot
     {
-        protected AggregateSnapshot(TIdentifier id, Int32 version, DateTime takenAt)
+        protected AggregateSnapshot(object id, Int32 version, DateTime takenAt)
         {
             if (version <= 0)
                 throw new ArgumentOutOfRangeException("version", "Version must be greater than 0.");
@@ -43,7 +42,7 @@ protected AggregateSnapshot(TIdentifier id, Int32 version, DateTime takenAt)
         }
 
         public Guid SnapshotId { get; private set; }
-        public TIdentifier Id { get; private set; }
+        public object Id { get; private set; }
         public Int32 Version { get; private set; }
         public DateTime TakenAt { get; private set; }
     }
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
index d860419..e24913e 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotLoadFrame.cs
@@ -25,15 +25,14 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public class AggregateSnapshotLoadFrame<TIdentifier> : AggregateLoadFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class AggregateSnapshotLoadFrame : AggregateLoadFrame
     {
-        public AggregateSnapshotLoadFrame(Type aggregateType, TIdentifier id, IAggregateSnapshot<TIdentifier> snapshot)
+        public AggregateSnapshotLoadFrame(Type aggregateType, object id, IAggregateSnapshot snapshot)
             : base(aggregateType, id)
         {
             Snapshot = Guard.NotNull(snapshot, "snapshot");
         }
 
-        public IAggregateSnapshot<TIdentifier> Snapshot { get; private set; }
+        public IAggregateSnapshot Snapshot { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
index d130912..34eec3e 100644
--- a/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/AggregateSnapshotSaveFrame.cs
@@ -25,15 +25,14 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public class AggregateSnapshotSaveFrame<TIdentifier> : AggregateSaveFrame<TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public class AggregateSnapshotSaveFrame : AggregateSaveFrame
     {
-        public AggregateSnapshotSaveFrame(Type aggregateType, TIdentifier id, Boolean isNew, IAggregateSnapshot<TIdentifier> snapshot)
+        public AggregateSnapshotSaveFrame(Type aggregateType, object id, Boolean isNew, IAggregateSnapshot snapshot)
             : base(aggregateType, id, isNew)
         {
             Snapshot = Guard.NotNull(snapshot, "snapshot");
         }
 
-        public IAggregateSnapshot<TIdentifier> Snapshot { get; private set; }
+        public IAggregateSnapshot Snapshot { get; private set; }
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
index 9006b6c..9a4dd51 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregate.cs
@@ -3,14 +3,22 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public interface IAggregate<out TIdentifier> 
-        where TIdentifier : IEquatable<TIdentifier>
+    public interface IAggregate
     {
-        TIdentifier Id { get; }
-        Int32 Version { get; }
+        object Id { get; }
+        int Version { get; }
+
+        IEnumerable<IAggregateEvent> GetUncommittedEvents();
+        IEnumerable<IAggregateEvent> GetEvents();
+        
+        IAggregateSnapshot TakeSnapshot();
+    }
 
-        IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents();
+    public interface IAggregate<out TIdentifier> : IAggregate 
+        where TIdentifier : IEquatable<TIdentifier>
+    {
+        new TIdentifier Id { get; }
 
-        IAggregateSnapshot<TIdentifier> TakeSnapshot();
+        new IEnumerable<IAggregateEvent<TIdentifier>> GetUncommittedEvents();
     }
 }
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs
deleted file mode 100644
index 46414b2..0000000
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateMemento.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// The MIT License
-// 
-// Copyright (c) 2013 Jordan E. Terrell
-// 
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-// 
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-// 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-using System;
-
-namespace iSynaptic.Modeling.Domain
-{
-    internal interface IAggregateMemento
-    {
-        AggregateMemento<TIdentifier> ToMemento<TIdentifier>()
-            where TIdentifier : IEquatable<TIdentifier>;
-    }
-}
\ No newline at end of file
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
index 65b2e1e..7ab562d 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregateRepository.cs
@@ -21,11 +21,20 @@
 // THE SOFTWARE.
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using iSynaptic.Commons.Threading.Tasks;
 
 namespace iSynaptic.Modeling.Domain
 {
+    public interface IAggregateRepository
+    {
+        Task<IAggregate> Get(Type aggregateType, object id, int maxVersion = int.MaxValue);
+        Task Save(IAggregate aggregate);
+        Task SaveSnapshot(IAggregate aggregate);
+        Task SaveEvents(Type aggregateType, object id, IEnumerable<IAggregateEvent> events);
+    }
+
     public interface IAggregateRepository<TAggregate, in TIdentifier> : IAggregateRepositoryCommands<TAggregate, TIdentifier>, IAggregateRepositoryQueries<TAggregate, TIdentifier>
         where TAggregate : IAggregate<TIdentifier> 
         where TIdentifier : IEquatable<TIdentifier>
diff --git a/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs b/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
index 90ff920..6583944 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IAggregateSnapshot.cs
@@ -24,12 +24,11 @@
 
 namespace iSynaptic.Modeling.Domain
 {
-    public interface IAggregateSnapshot<out TIdentifier>
-        where TIdentifier : IEquatable<TIdentifier>
+    public interface IAggregateSnapshot
     {
         Guid SnapshotId { get; }
 
-        TIdentifier Id { get; }
+        object Id { get; }
         Int32 Version { get; }
 
         DateTime TakenAt { get; }
diff --git a/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs b/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs
index a3a3b07..b53944e 100644
--- a/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs
+++ b/src/iSynaptic.Core/Modeling/Domain/IScalarValue.cs
@@ -20,6 +20,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+using System;
+
 namespace iSynaptic.Modeling.Domain
 {
     public interface IScalarValue
diff --git a/src/iSynaptic.Core/iSynaptic.Core.csproj b/src/iSynaptic.Core/iSynaptic.Core.csproj
index 5d7b3a4..6fd0d7e 100644
--- a/src/iSynaptic.Core/iSynaptic.Core.csproj
+++ b/src/iSynaptic.Core/iSynaptic.Core.csproj
@@ -75,7 +75,6 @@
     <Compile Include="Modeling\Domain\AggregateSnapshotSaveFrame.cs" />
     <Compile Include="Modeling\Domain\IAggregate.cs" />
     <Compile Include="Modeling\Domain\IAggregateEvent.cs" />
-    <Compile Include="Modeling\Domain\IAggregateMemento.cs" />
     <Compile Include="Modeling\Domain\IAggregateRepository.cs" />
     <Compile Include="Modeling\Domain\IAggregateSnapshot.cs" />
     <Compile Include="Modeling\Domain\ImmuneToResetAttribute.cs" />