diff --git a/src/Persistence/MartenTests/MartenOps_store.cs b/src/Persistence/MartenTests/MartenOps_store.cs
new file mode 100644
index 000000000..b091f85cb
--- /dev/null
+++ b/src/Persistence/MartenTests/MartenOps_store.cs
@@ -0,0 +1,64 @@
+using Shouldly;
+using Wolverine.Marten;
+
+namespace MartenTests;
+
+public class MartenOps_store
+{
+    [Fact]
+    public void StoreMany()
+    {
+        var op = MartenOps.StoreMany(new MartenMessage2("Test1"));
+
+        op.Documents.Count.ShouldBe(1);
+        op.Documents[0].ShouldBeOfType<MartenMessage2>();
+
+        op.With(new MartenMessage2("Test2"));
+
+        op.Documents.Count.ShouldBe(2);
+
+        op.With([new MartenMessage2("Test3"), new MartenMessage2("Test4")]);
+
+        op.Documents.Count.ShouldBe(4);
+
+        op = MartenOps.StoreMany(new MartenMessage2("Test5"), new MartenMessage2("Test6"));
+
+        op.Documents.Count.ShouldBe(2);
+
+        op = MartenOps.StoreMany([new MartenMessage2("Test7"), new MartenMessage2("Test8")]);
+
+        op.Documents.Count.ShouldBe(2);
+    }
+
+    [Fact]
+    public void StoreObjects()
+    {
+        var op = MartenOps.StoreObjects(new MartenMessage2("Test1"));
+
+        op.Documents.Count.ShouldBe(1);
+        op.Documents[0].ShouldBeOfType<MartenMessage2>();
+
+        op.With(new MartenMessage3("Test2"));
+
+        op.Documents.Count.ShouldBe(2);
+        op.Documents[1].ShouldBeOfType<MartenMessage3>();
+
+        op.With([new MartenMessage2("Test3"), new MartenMessage3("Test4")]);
+
+        op.Documents.Count.ShouldBe(4);
+        op.Documents[2].ShouldBeOfType<MartenMessage2>();
+        op.Documents[3].ShouldBeOfType<MartenMessage3>();
+
+        op = MartenOps.StoreObjects(new MartenMessage2("Test5"), new MartenMessage3("Test6"));
+
+        op.Documents.Count.ShouldBe(2);
+        op.Documents[0].ShouldBeOfType<MartenMessage2>();
+        op.Documents[1].ShouldBeOfType<MartenMessage3>();
+
+        op = MartenOps.StoreObjects([new MartenMessage2("Test7"), new MartenMessage3("Test8")]);
+
+        op.Documents.Count.ShouldBe(2);
+        op.Documents[0].ShouldBeOfType<MartenMessage2>();
+        op.Documents[1].ShouldBeOfType<MartenMessage3>();
+    }
+}
\ No newline at end of file
diff --git a/src/Persistence/Wolverine.Marten/IMartenOp.cs b/src/Persistence/Wolverine.Marten/IMartenOp.cs
index ece593013..6a2b37496 100644
--- a/src/Persistence/Wolverine.Marten/IMartenOp.cs
+++ b/src/Persistence/Wolverine.Marten/IMartenOp.cs
@@ -109,6 +109,22 @@ public static StoreManyDocs<T> StoreMany<T>(params T[] documents) where T : notn
         return new StoreManyDocs<T>(documents);
     }
 
+    /// <summary>
+    /// Return a side effect of storing an enumerable of potentially mixed documents in Marten
+    /// </summary>
+    /// <param name="documents"></param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentNullException"></exception>
+    public static StoreObjects StoreObjects(params object[] documents)
+    {
+        if (documents == null)
+        {
+            throw new ArgumentNullException(nameof(documents));
+        }
+
+        return new StoreObjects(documents);
+    }
+
     /// <summary>
     /// Return a side effect of inserting the specified document in Marten
     /// </summary>
@@ -406,18 +422,49 @@ public override void Execute(IDocumentSession session)
 
 public class StoreManyDocs<T> : DocumentsOp where T : notnull
 {
-    private readonly T[] _documents;
+    public StoreManyDocs(params T[] documents) : base(documents.Cast<object>().ToArray()) { }
+
+    public StoreManyDocs(IList<T> documents) : this(documents.ToArray()) { }
 
-    public StoreManyDocs(params T[] documents) : base(documents.Cast<object>().ToArray())
+    public StoreManyDocs<T> With(T[] documents)
     {
-        _documents = documents;
+        Documents.AddRange(documents.Cast<object>());
+        return this;
     }
 
-    public StoreManyDocs(IList<T> documents) : this(documents.ToArray()) { }
+    public StoreManyDocs<T> With(T document)
+    {
+        Documents.Add(document);
+        return this;
+    }
 
     public override void Execute(IDocumentSession session)
     {
-        session.Store(_documents);
+        session.Store(Documents.Cast<T>());
+    }
+}
+
+public class StoreObjects : DocumentsOp
+{
+    public StoreObjects(params object[] documents) : base(documents) { }
+
+    public StoreObjects(IList<object> documents) : this(documents.ToArray()) { }
+
+    public StoreObjects With(object[] documents)
+    {
+        Documents.AddRange(documents);
+        return this;
+    }
+
+    public StoreObjects With(object document)
+    {
+        Documents.Add(document);
+        return this;
+    }
+
+    public override void Execute(IDocumentSession session)
+    {
+        session.StoreObjects(Documents);
     }
 }
 
@@ -525,14 +572,21 @@ protected DocumentOp(object document)
     public abstract void Execute(IDocumentSession session);
 }
 
-public abstract class DocumentsOp : IMartenOp
+public interface IDocumentsOp : IMartenOp
 {
-    public object[] Documents { get; }
+    IReadOnlyList<object> Documents { get; }
+}
+
+public abstract class DocumentsOp : IDocumentsOp
+{
+    public List<object> Documents { get; } = new();
 
     protected DocumentsOp(params object[] documents)
     {
-        Documents = documents;
+        Documents.AddRange(documents);
     }
 
     public abstract void Execute(IDocumentSession session);
+
+    IReadOnlyList<object> IDocumentsOp.Documents => Documents;
 }