diff --git a/README.md b/README.md
index cf8101ab2..7a2261772 100644
--- a/README.md
+++ b/README.md
@@ -336,13 +336,13 @@ public class MyHook : Hook
   }
 
   public ValueTask AfterAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
-      IReadOnlyDictionary<string, object> hints = null)
+      IReadOnlyDictionary<string, object>? hints = null)
   {
     // code to run after successful flag evaluation
   }
 
   public ValueTask ErrorAsync<T>(HookContext<T> context, Exception error,
-      IReadOnlyDictionary<string, object> hints = null)
+      IReadOnlyDictionary<string, object>? hints = null)
   {
     // code to run if there's an error during before hooks or during flag evaluation
   }
@@ -354,6 +354,29 @@ public class MyHook : Hook
 }
 ```
 
+Hooks support passing per-evaluation data between that stages using `hook data`. The below example hook uses `hook data` to measure the duration between the execution of the `before` and `after` stage.
+
+```csharp
+    class TimingHook : Hook
+    {
+        public ValueTask<EvaluationContext> BeforeAsync<T>(HookContext<T> context,
+            IReadOnlyDictionary<string, object>? hints = null)
+        {
+            context.Data.Set("beforeTime", DateTime.Now);
+            return ValueTask.FromResult(context.EvaluationContext);
+        }
+
+        public ValueTask AfterAsync<T>(HookContext<T> context, FlagEvaluationDetails<T> details,
+            IReadOnlyDictionary<string, object>? hints = null)
+        {
+            var beforeTime = context.Data.Get("beforeTime") as DateTime?;
+            var duration = DateTime.Now - beforeTime;
+            Console.WriteLine($"Duration: {duration}");
+            return ValueTask.CompletedTask;
+        }
+    }
+```
+
 Built a new hook? [Let us know](https://github.com/open-feature/openfeature.dev/issues/new?assignees=&labels=hook&projects=&template=document-hook.yaml&title=%5BHook%5D%3A+) so we can add it to the docs!
 
 ### DependencyInjection
diff --git a/src/OpenFeature/HookData.cs b/src/OpenFeature/HookData.cs
new file mode 100644
index 000000000..5d56eb870
--- /dev/null
+++ b/src/OpenFeature/HookData.cs
@@ -0,0 +1,104 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using OpenFeature.Model;
+
+namespace OpenFeature
+{
+    /// <summary>
+    /// A key-value collection of strings to objects used for passing data between hook stages.
+    /// <para>
+    /// This collection is scoped to a single evaluation for a single hook. Each hook stage for the evaluation
+    /// will share the same <see cref="HookData"/>.
+    /// </para>
+    /// <para>
+    /// This collection is intended for use only during the execution of individual hook stages, a reference
+    /// to the collection should not be retained.
+    /// </para>
+    /// <para>
+    /// This collection is not thread-safe.
+    /// </para>
+    /// </summary>
+    /// <seealso href="https://github.com/open-feature/spec/blob/main/specification/sections/04-hooks.md#46-hook-data"/>
+    public sealed class HookData
+    {
+        private readonly Dictionary<string, object> _data = [];
+
+        /// <summary>
+        /// Set the key to the given value.
+        /// </summary>
+        /// <param name="key">The key for the value</param>
+        /// <param name="value">The value to set</param>
+        /// <returns>This hook data instance</returns>
+        public HookData Set(string key, object value)
+        {
+            this._data[key] = value;
+            return this;
+        }
+
+        /// <summary>
+        /// Gets the value at the specified key as an object.
+        /// <remarks>
+        /// For <see cref="Value"/> types use <see cref="Get"/> instead.
+        /// </remarks>
+        /// </summary>
+        /// <param name="key">The key of the value to be retrieved</param>
+        /// <returns>The object associated with the key</returns>
+        /// <exception cref="KeyNotFoundException">
+        /// Thrown when the context does not contain the specified key
+        /// </exception>
+        public object Get(string key)
+        {
+            return this._data[key];
+        }
+
+        /// <summary>
+        /// Return a count of all values.
+        /// </summary>
+        public int Count => this._data.Count;
+
+        /// <summary>
+        /// Return an enumerator for all values.
+        /// </summary>
+        /// <returns>An enumerator for all values</returns>
+        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
+        {
+            return this._data.GetEnumerator();
+        }
+
+        /// <summary>
+        /// Return a list containing all the keys in the hook data
+        /// </summary>
+        public IImmutableList<string> Keys => this._data.Keys.ToImmutableList();
+
+        /// <summary>
+        /// Return an enumerable containing all the values of the hook data
+        /// </summary>
+        public IImmutableList<object> Values => this._data.Values.ToImmutableList();
+
+        /// <summary>
+        /// Gets all values as a read only dictionary.
+        /// <remarks>
+        /// The dictionary references the original values and is not a thread-safe copy.
+        /// </remarks>
+        /// </summary>
+        /// <returns>A <see cref="IDictionary{TKey,TValue}"/> representation of the hook data</returns>
+        public IReadOnlyDictionary<string, object> AsDictionary()
+        {
+            return this._data;
+        }
+
+        /// <summary>
+        /// Gets or sets the value associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key of the value to get or set</param>
+        /// <returns>The value associated with the specified key</returns>
+        /// <exception cref="KeyNotFoundException">
+        /// Thrown when getting a value and the context does not contain the specified key
+        /// </exception>
+        public object this[string key]
+        {
+            get => this.Get(key);
+            set => this.Set(key, value);
+        }
+    }
+}
diff --git a/src/OpenFeature/HookRunner.cs b/src/OpenFeature/HookRunner.cs
new file mode 100644
index 000000000..8c1dbb510
--- /dev/null
+++ b/src/OpenFeature/HookRunner.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using OpenFeature.Model;
+
+namespace OpenFeature
+{
+    /// <summary>
+    /// This class manages the execution of hooks.
+    /// </summary>
+    /// <typeparam name="T">type of the evaluation detail provided to the hooks</typeparam>
+    internal partial class HookRunner<T>
+    {
+        private readonly ImmutableList<Hook> _hooks;
+
+        private readonly List<HookContext<T>> _hookContexts;
+
+        private EvaluationContext _evaluationContext;
+
+        private readonly ILogger _logger;
+
+        /// <summary>
+        /// Construct a hook runner instance. Each instance should be used for the execution of a single evaluation.
+        /// </summary>
+        /// <param name="hooks">
+        /// The hooks for the evaluation, these should be in the correct order for the before evaluation stage
+        /// </param>
+        /// <param name="evaluationContext">
+        /// The initial evaluation context, this can be updated as the hooks execute
+        /// </param>
+        /// <param name="sharedHookContext">
+        /// Contents of the initial hook context excluding the evaluation context and hook data
+        /// </param>
+        /// <param name="logger">Client logger instance</param>
+        public HookRunner(ImmutableList<Hook> hooks, EvaluationContext evaluationContext,
+            SharedHookContext<T> sharedHookContext,
+            ILogger logger)
+        {
+            this._evaluationContext = evaluationContext;
+            this._logger = logger;
+            this._hooks = hooks;
+            this._hookContexts = new List<HookContext<T>>(hooks.Count);
+            for (var i = 0; i < hooks.Count; i++)
+            {
+                // Create hook instance specific hook context.
+                // Hook contexts are instance specific so that the mutable hook data is scoped to each hook.
+                this._hookContexts.Add(sharedHookContext.ToHookContext(evaluationContext));
+            }
+        }
+
+        /// <summary>
+        /// Execute before hooks.
+        /// </summary>
+        /// <param name="hints">Optional hook hints</param>
+        /// <param name="cancellationToken">Cancellation token which can cancel hook operations</param>
+        /// <returns>Context with any modifications from the before hooks</returns>
+        public async Task<EvaluationContext> TriggerBeforeHooksAsync(IImmutableDictionary<string, object>? hints,
+            CancellationToken cancellationToken = default)
+        {
+            var evalContextBuilder = EvaluationContext.Builder();
+            evalContextBuilder.Merge(this._evaluationContext);
+
+            for (var i = 0; i < this._hooks.Count; i++)
+            {
+                var hook = this._hooks[i];
+                var hookContext = this._hookContexts[i];
+
+                var resp = await hook.BeforeAsync(hookContext, hints, cancellationToken)
+                    .ConfigureAwait(false);
+                if (resp != null)
+                {
+                    evalContextBuilder.Merge(resp);
+                    this._evaluationContext = evalContextBuilder.Build();
+                    for (var j = 0; j < this._hookContexts.Count; j++)
+                    {
+                        this._hookContexts[j] = this._hookContexts[j].WithNewEvaluationContext(this._evaluationContext);
+                    }
+                }
+                else
+                {
+                    this.HookReturnedNull(hook.GetType().Name);
+                }
+            }
+
+            return this._evaluationContext;
+        }
+
+        /// <summary>
+        /// Execute the after hooks. These are executed in opposite order of the before hooks.
+        /// </summary>
+        /// <param name="evaluationDetails">The evaluation details which will be provided to the hook</param>
+        /// <param name="hints">Optional hook hints</param>
+        /// <param name="cancellationToken">Cancellation token which can cancel hook operations</param>
+        public async Task TriggerAfterHooksAsync(FlagEvaluationDetails<T> evaluationDetails,
+            IImmutableDictionary<string, object>? hints,
+            CancellationToken cancellationToken = default)
+        {
+            // After hooks run in reverse.
+            for (var i = this._hooks.Count - 1; i >= 0; i--)
+            {
+                var hook = this._hooks[i];
+                var hookContext = this._hookContexts[i];
+                await hook.AfterAsync(hookContext, evaluationDetails, hints, cancellationToken)
+                    .ConfigureAwait(false);
+            }
+        }
+
+        /// <summary>
+        /// Execute the error hooks. These are executed in opposite order of the before hooks.
+        /// </summary>
+        /// <param name="exception">Exception which triggered the error</param>
+        /// <param name="hints">Optional hook hints</param>
+        /// <param name="cancellationToken">Cancellation token which can cancel hook operations</param>
+        public async Task TriggerErrorHooksAsync(Exception exception,
+            IImmutableDictionary<string, object>? hints, CancellationToken cancellationToken = default)
+        {
+            // Error hooks run in reverse.
+            for (var i = this._hooks.Count - 1; i >= 0; i--)
+            {
+                var hook = this._hooks[i];
+                var hookContext = this._hookContexts[i];
+                try
+                {
+                    await hook.ErrorAsync(hookContext, exception, hints, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                catch (Exception e)
+                {
+                    this.ErrorHookError(hook.GetType().Name, e);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Execute the finally hooks. These are executed in opposite order of the before hooks.
+        /// </summary>
+        /// <param name="evaluationDetails">The evaluation details which will be provided to the hook</param>
+        /// <param name="hints">Optional hook hints</param>
+        /// <param name="cancellationToken">Cancellation token which can cancel hook operations</param>
+        public async Task TriggerFinallyHooksAsync(FlagEvaluationDetails<T> evaluationDetails,
+            IImmutableDictionary<string, object>? hints,
+            CancellationToken cancellationToken = default)
+        {
+            // Finally hooks run in reverse
+            for (var i = this._hooks.Count - 1; i >= 0; i--)
+            {
+                var hook = this._hooks[i];
+                var hookContext = this._hookContexts[i];
+                try
+                {
+                    await hook.FinallyAsync(hookContext, evaluationDetails, hints, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+                catch (Exception e)
+                {
+                    this.FinallyHookError(hook.GetType().Name, e);
+                }
+            }
+        }
+
+        [LoggerMessage(100, LogLevel.Debug, "Hook {HookName} returned null, nothing to merge back into context")]
+        partial void HookReturnedNull(string hookName);
+
+        [LoggerMessage(103, LogLevel.Error, "Error while executing Error hook {HookName}")]
+        partial void ErrorHookError(string hookName, Exception exception);
+
+        [LoggerMessage(104, LogLevel.Error, "Error while executing Finally hook {HookName}")]
+        partial void FinallyHookError(string hookName, Exception exception);
+    }
+}
diff --git a/src/OpenFeature/Model/HookContext.cs b/src/OpenFeature/Model/HookContext.cs
index 69f58bde8..8d99a2836 100644
--- a/src/OpenFeature/Model/HookContext.cs
+++ b/src/OpenFeature/Model/HookContext.cs
@@ -10,20 +10,22 @@ namespace OpenFeature.Model
     /// <seealso href="https://github.com/open-feature/spec/blob/v0.5.2/specification/sections/04-hooks.md#41-hook-context"/>
     public sealed class HookContext<T>
     {
+        private readonly SharedHookContext<T> _shared;
+
         /// <summary>
         /// Feature flag being evaluated
         /// </summary>
-        public string FlagKey { get; }
+        public string FlagKey => this._shared.FlagKey;
 
         /// <summary>
         /// Default value if flag fails to be evaluated
         /// </summary>
-        public T DefaultValue { get; }
+        public T DefaultValue => this._shared.DefaultValue;
 
         /// <summary>
         /// The value type of the flag
         /// </summary>
-        public FlagValueType FlagValueType { get; }
+        public FlagValueType FlagValueType => this._shared.FlagValueType;
 
         /// <summary>
         /// User defined evaluation context used in the evaluation process
@@ -34,12 +36,17 @@ public sealed class HookContext<T>
         /// <summary>
         /// Client metadata
         /// </summary>
-        public ClientMetadata ClientMetadata { get; }
+        public ClientMetadata ClientMetadata => this._shared.ClientMetadata;
 
         /// <summary>
         /// Provider metadata
         /// </summary>
-        public Metadata ProviderMetadata { get; }
+        public Metadata ProviderMetadata => this._shared.ProviderMetadata;
+
+        /// <summary>
+        /// Hook data
+        /// </summary>
+        public HookData Data { get; }
 
         /// <summary>
         /// Initialize a new instance of <see cref="HookContext{T}"/>
@@ -58,23 +65,27 @@ public HookContext(string? flagKey,
             Metadata? providerMetadata,
             EvaluationContext? evaluationContext)
         {
-            this.FlagKey = flagKey ?? throw new ArgumentNullException(nameof(flagKey));
-            this.DefaultValue = defaultValue;
-            this.FlagValueType = flagValueType;
-            this.ClientMetadata = clientMetadata ?? throw new ArgumentNullException(nameof(clientMetadata));
-            this.ProviderMetadata = providerMetadata ?? throw new ArgumentNullException(nameof(providerMetadata));
+            this._shared = new SharedHookContext<T>(
+                flagKey, defaultValue, flagValueType, clientMetadata, providerMetadata);
+
+            this.EvaluationContext = evaluationContext ?? throw new ArgumentNullException(nameof(evaluationContext));
+            this.Data = new HookData();
+        }
+
+        internal HookContext(SharedHookContext<T>? sharedHookContext, EvaluationContext? evaluationContext,
+            HookData? hookData)
+        {
+            this._shared = sharedHookContext ?? throw new ArgumentNullException(nameof(sharedHookContext));
             this.EvaluationContext = evaluationContext ?? throw new ArgumentNullException(nameof(evaluationContext));
+            this.Data = hookData ?? throw new ArgumentNullException(nameof(hookData));
         }
 
         internal HookContext<T> WithNewEvaluationContext(EvaluationContext context)
         {
             return new HookContext<T>(
-                this.FlagKey,
-                this.DefaultValue,
-                this.FlagValueType,
-                this.ClientMetadata,
-                this.ProviderMetadata,
-                context
+                this._shared,
+                context,
+                this.Data
             );
         }
     }
diff --git a/src/OpenFeature/OpenFeatureClient.cs b/src/OpenFeature/OpenFeatureClient.cs
index 03420a2a4..4a00aa440 100644
--- a/src/OpenFeature/OpenFeatureClient.cs
+++ b/src/OpenFeature/OpenFeatureClient.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -222,32 +223,29 @@ private async Task<FlagEvaluationDetails<T>> EvaluateFlagAsync<T>(
             evaluationContextBuilder.Merge(Api.Instance.GetTransactionContext()); // Transaction context
             evaluationContextBuilder.Merge(context); // Invocation context
 
-            var allHooks = new List<Hook>()
+            var allHooks = ImmutableList.CreateBuilder<Hook>()
                 .Concat(Api.Instance.GetHooks())
                 .Concat(this.GetHooks())
                 .Concat(options?.Hooks ?? Enumerable.Empty<Hook>())
                 .Concat(provider.GetProviderHooks())
-                .ToList()
-                .AsReadOnly();
+                .ToImmutableList();
 
-            var allHooksReversed = allHooks
-                .AsEnumerable()
-                .Reverse()
-                .ToList()
-                .AsReadOnly();
-
-            var hookContext = new HookContext<T>(
+            var sharedHookContext = new SharedHookContext<T>(
                 flagKey,
                 defaultValue,
-                flagValueType, this._metadata,
-                provider.GetMetadata(),
-                evaluationContextBuilder.Build()
+                flagValueType,
+                this._metadata,
+                provider.GetMetadata()
             );
 
             FlagEvaluationDetails<T>? evaluation = null;
+            var hookRunner = new HookRunner<T>(allHooks, evaluationContextBuilder.Build(), sharedHookContext,
+                this._logger);
+
             try
             {
-                var contextFromHooks = await this.TriggerBeforeHooksAsync(allHooks, hookContext, options, cancellationToken).ConfigureAwait(false);
+                var evaluationContextFromHooks = await hookRunner.TriggerBeforeHooksAsync(options?.HookHints, cancellationToken)
+                    .ConfigureAwait(false);
 
                 // short circuit evaluation entirely if provider is in a bad state
                 if (provider.Status == ProviderStatus.NotReady)
@@ -260,23 +258,24 @@ private async Task<FlagEvaluationDetails<T>> EvaluateFlagAsync<T>(
                 }
 
                 evaluation =
-                    (await resolveValueDelegate.Invoke(flagKey, defaultValue, contextFromHooks.EvaluationContext, cancellationToken).ConfigureAwait(false))
+                    (await resolveValueDelegate
+                        .Invoke(flagKey, defaultValue, evaluationContextFromHooks, cancellationToken)
+                        .ConfigureAwait(false))
                     .ToFlagEvaluationDetails();
 
                 if (evaluation.ErrorType == ErrorType.None)
                 {
-                    await this.TriggerAfterHooksAsync(
-                        allHooksReversed,
-                        hookContext,
+                    await hookRunner.TriggerAfterHooksAsync(
                         evaluation,
-                        options,
+                        options?.HookHints,
                         cancellationToken
                     ).ConfigureAwait(false);
                 }
                 else
                 {
                     var exception = new FeatureProviderException(evaluation.ErrorType, evaluation.ErrorMessage);
-                    await this.TriggerErrorHooksAsync(allHooksReversed, hookContext, exception, options, cancellationToken)
+                    this.FlagEvaluationErrorWithDescription(flagKey, evaluation.ErrorType.GetDescription(), exception);
+                    await hookRunner.TriggerErrorHooksAsync(exception, options?.HookHints, cancellationToken)
                         .ConfigureAwait(false);
                 }
             }
@@ -285,88 +284,29 @@ await this.TriggerErrorHooksAsync(allHooksReversed, hookContext, exception, opti
                 this.FlagEvaluationErrorWithDescription(flagKey, ex.ErrorType.GetDescription(), ex);
                 evaluation = new FlagEvaluationDetails<T>(flagKey, defaultValue, ex.ErrorType, Reason.Error,
                     string.Empty, ex.Message);
-                await this.TriggerErrorHooksAsync(allHooksReversed, hookContext, ex, options, cancellationToken).ConfigureAwait(false);
+                await hookRunner.TriggerErrorHooksAsync(ex, options?.HookHints, cancellationToken)
+                    .ConfigureAwait(false);
             }
             catch (Exception ex)
             {
                 var errorCode = ex is InvalidCastException ? ErrorType.TypeMismatch : ErrorType.General;
-                evaluation = new FlagEvaluationDetails<T>(flagKey, defaultValue, errorCode, Reason.Error, string.Empty, ex.Message);
-                await this.TriggerErrorHooksAsync(allHooksReversed, hookContext, ex, options, cancellationToken).ConfigureAwait(false);
+                evaluation = new FlagEvaluationDetails<T>(flagKey, defaultValue, errorCode, Reason.Error, string.Empty,
+                    ex.Message);
+                await hookRunner.TriggerErrorHooksAsync(ex, options?.HookHints, cancellationToken)
+                    .ConfigureAwait(false);
             }
             finally
             {
-                evaluation ??= new FlagEvaluationDetails<T>(flagKey, defaultValue, ErrorType.General, Reason.Error, string.Empty,
+                evaluation ??= new FlagEvaluationDetails<T>(flagKey, defaultValue, ErrorType.General, Reason.Error,
+                    string.Empty,
                     "Evaluation failed to return a result.");
-                await this.TriggerFinallyHooksAsync(allHooksReversed, evaluation, hookContext, options, cancellationToken).ConfigureAwait(false);
+                await hookRunner.TriggerFinallyHooksAsync(evaluation, options?.HookHints, cancellationToken)
+                    .ConfigureAwait(false);
             }
 
             return evaluation;
         }
 
-        private async Task<HookContext<T>> TriggerBeforeHooksAsync<T>(IReadOnlyList<Hook> hooks, HookContext<T> context,
-            FlagEvaluationOptions? options, CancellationToken cancellationToken = default)
-        {
-            var evalContextBuilder = EvaluationContext.Builder();
-            evalContextBuilder.Merge(context.EvaluationContext);
-
-            foreach (var hook in hooks)
-            {
-                var resp = await hook.BeforeAsync(context, options?.HookHints, cancellationToken).ConfigureAwait(false);
-                if (resp != null)
-                {
-                    evalContextBuilder.Merge(resp);
-                    context = context.WithNewEvaluationContext(evalContextBuilder.Build());
-                }
-                else
-                {
-                    this.HookReturnedNull(hook.GetType().Name);
-                }
-            }
-
-            return context.WithNewEvaluationContext(evalContextBuilder.Build());
-        }
-
-        private async Task TriggerAfterHooksAsync<T>(IReadOnlyList<Hook> hooks, HookContext<T> context,
-            FlagEvaluationDetails<T> evaluationDetails, FlagEvaluationOptions? options, CancellationToken cancellationToken = default)
-        {
-            foreach (var hook in hooks)
-            {
-                await hook.AfterAsync(context, evaluationDetails, options?.HookHints, cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        private async Task TriggerErrorHooksAsync<T>(IReadOnlyList<Hook> hooks, HookContext<T> context, Exception exception,
-            FlagEvaluationOptions? options, CancellationToken cancellationToken = default)
-        {
-            foreach (var hook in hooks)
-            {
-                try
-                {
-                    await hook.ErrorAsync(context, exception, options?.HookHints, cancellationToken).ConfigureAwait(false);
-                }
-                catch (Exception e)
-                {
-                    this.ErrorHookError(hook.GetType().Name, e);
-                }
-            }
-        }
-
-        private async Task TriggerFinallyHooksAsync<T>(IReadOnlyList<Hook> hooks, FlagEvaluationDetails<T> evaluation,
-            HookContext<T> context, FlagEvaluationOptions? options, CancellationToken cancellationToken = default)
-        {
-            foreach (var hook in hooks)
-            {
-                try
-                {
-                    await hook.FinallyAsync(context, evaluation, options?.HookHints, cancellationToken).ConfigureAwait(false);
-                }
-                catch (Exception e)
-                {
-                    this.FinallyHookError(hook.GetType().Name, e);
-                }
-            }
-        }
-
         /// <summary>
         /// Use this method to track user interactions and the application state.
         /// </summary>
@@ -392,16 +332,13 @@ public void Track(string trackingEventName, EvaluationContext? evaluationContext
             this._providerAccessor.Invoke().Track(trackingEventName, evaluationContextBuilder.Build(), trackingEventDetails);
         }
 
+        [LoggerMessage(101, LogLevel.Error, "Error while evaluating flag {FlagKey}")]
+        partial void FlagEvaluationError(string flagKey, Exception exception);
+
         [LoggerMessage(100, LogLevel.Debug, "Hook {HookName} returned null, nothing to merge back into context")]
         partial void HookReturnedNull(string hookName);
 
         [LoggerMessage(102, LogLevel.Error, "Error while evaluating flag {FlagKey}: {ErrorType}")]
         partial void FlagEvaluationErrorWithDescription(string flagKey, string errorType, Exception exception);
-
-        [LoggerMessage(103, LogLevel.Error, "Error while executing Error hook {HookName}")]
-        partial void ErrorHookError(string hookName, Exception exception);
-
-        [LoggerMessage(104, LogLevel.Error, "Error while executing Finally hook {HookName}")]
-        partial void FinallyHookError(string hookName, Exception exception);
     }
 }
diff --git a/src/OpenFeature/SharedHookContext.cs b/src/OpenFeature/SharedHookContext.cs
new file mode 100644
index 000000000..3d6b787c6
--- /dev/null
+++ b/src/OpenFeature/SharedHookContext.cs
@@ -0,0 +1,60 @@
+using System;
+using OpenFeature.Constant;
+using OpenFeature.Model;
+
+namespace OpenFeature
+{
+    /// <summary>
+    /// Component of the hook context which shared between all hook instances
+    /// </summary>
+    /// <param name="flagKey">Feature flag key</param>
+    /// <param name="defaultValue">Default value</param>
+    /// <param name="flagValueType">Flag value type</param>
+    /// <param name="clientMetadata">Client metadata</param>
+    /// <param name="providerMetadata">Provider metadata</param>
+    /// <typeparam name="T">Flag value type</typeparam>
+    internal class SharedHookContext<T>(
+        string? flagKey,
+        T defaultValue,
+        FlagValueType flagValueType,
+        ClientMetadata? clientMetadata,
+        Metadata? providerMetadata)
+    {
+        /// <summary>
+        /// Feature flag being evaluated
+        /// </summary>
+        public string FlagKey { get; } = flagKey ?? throw new ArgumentNullException(nameof(flagKey));
+
+        /// <summary>
+        /// Default value if flag fails to be evaluated
+        /// </summary>
+        public T DefaultValue { get; } = defaultValue;
+
+        /// <summary>
+        /// The value type of the flag
+        /// </summary>
+        public FlagValueType FlagValueType { get; } = flagValueType;
+
+        /// <summary>
+        /// Client metadata
+        /// </summary>
+        public ClientMetadata ClientMetadata { get; } =
+            clientMetadata ?? throw new ArgumentNullException(nameof(clientMetadata));
+
+        /// <summary>
+        /// Provider metadata
+        /// </summary>
+        public Metadata ProviderMetadata { get; } =
+            providerMetadata ?? throw new ArgumentNullException(nameof(providerMetadata));
+
+        /// <summary>
+        /// Create a hook context from this shared context.
+        /// </summary>
+        /// <param name="evaluationContext">Evaluation context</param>
+        /// <returns>A hook context</returns>
+        public HookContext<T> ToHookContext(EvaluationContext? evaluationContext)
+        {
+            return new HookContext<T>(this, evaluationContext, new HookData());
+        }
+    }
+}
diff --git a/test/OpenFeature.Tests/HookDataTests.cs b/test/OpenFeature.Tests/HookDataTests.cs
new file mode 100644
index 000000000..96cbaf723
--- /dev/null
+++ b/test/OpenFeature.Tests/HookDataTests.cs
@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using OpenFeature.Model;
+using Xunit;
+
+namespace OpenFeature.Tests;
+
+public class HookDataTests
+{
+    private readonly HookData _commonHookData = new();
+
+    public HookDataTests()
+    {
+        this._commonHookData.Set("bool", true);
+        this._commonHookData.Set("string", "string");
+        this._commonHookData.Set("int", 1);
+        this._commonHookData.Set("double", 1.2);
+        this._commonHookData.Set("float", 1.2f);
+    }
+
+    [Fact]
+    public void HookData_Can_Set_And_Get_Data()
+    {
+        var hookData = new HookData();
+        hookData.Set("bool", true);
+        hookData.Set("string", "string");
+        hookData.Set("int", 1);
+        hookData.Set("double", 1.2);
+        hookData.Set("float", 1.2f);
+        var structure = Structure.Builder().Build();
+        hookData.Set("structure", structure);
+
+        Assert.True((bool)hookData.Get("bool"));
+        Assert.Equal("string", hookData.Get("string"));
+        Assert.Equal(1, hookData.Get("int"));
+        Assert.Equal(1.2, hookData.Get("double"));
+        Assert.Equal(1.2f, hookData.Get("float"));
+        Assert.Same(structure, hookData.Get("structure"));
+    }
+
+    [Fact]
+    public void HookData_Can_Chain_Set()
+    {
+        var structure = Structure.Builder().Build();
+
+        var hookData = new HookData();
+        hookData.Set("bool", true)
+            .Set("string", "string")
+            .Set("int", 1)
+            .Set("double", 1.2)
+            .Set("float", 1.2f)
+            .Set("structure", structure);
+
+        Assert.True((bool)hookData.Get("bool"));
+        Assert.Equal("string", hookData.Get("string"));
+        Assert.Equal(1, hookData.Get("int"));
+        Assert.Equal(1.2, hookData.Get("double"));
+        Assert.Equal(1.2f, hookData.Get("float"));
+        Assert.Same(structure, hookData.Get("structure"));
+    }
+
+    [Fact]
+    public void HookData_Can_Set_And_Get_Data_Using_Indexer()
+    {
+        var hookData = new HookData();
+        hookData["bool"] = true;
+        hookData["string"] = "string";
+        hookData["int"] = 1;
+        hookData["double"] = 1.2;
+        hookData["float"] = 1.2f;
+        var structure = Structure.Builder().Build();
+        hookData["structure"] = structure;
+
+        Assert.True((bool)hookData["bool"]);
+        Assert.Equal("string", hookData["string"]);
+        Assert.Equal(1, hookData["int"]);
+        Assert.Equal(1.2, hookData["double"]);
+        Assert.Equal(1.2f, hookData["float"]);
+        Assert.Same(structure, hookData["structure"]);
+    }
+
+    [Fact]
+    public void HookData_Can_Be_Enumerated()
+    {
+        var asList = new List<KeyValuePair<string, object>>();
+        foreach (var kvp in this._commonHookData)
+        {
+            asList.Add(kvp);
+        }
+
+        asList.Sort((a, b) =>
+            string.Compare(a.Key, b.Key, StringComparison.Ordinal));
+
+        Assert.Equal([
+            new KeyValuePair<string, object>("bool", true),
+            new KeyValuePair<string, object>("double", 1.2),
+            new KeyValuePair<string, object>("float", 1.2f),
+            new KeyValuePair<string, object>("int", 1),
+            new KeyValuePair<string, object>("string", "string")
+        ], asList);
+    }
+
+    [Fact]
+    public void HookData_Has_Count()
+    {
+        Assert.Equal(5, this._commonHookData.Count);
+    }
+
+    [Fact]
+    public void HookData_Has_Keys()
+    {
+        Assert.Equal(5, this._commonHookData.Keys.Count);
+        Assert.Contains("bool", this._commonHookData.Keys);
+        Assert.Contains("double", this._commonHookData.Keys);
+        Assert.Contains("float", this._commonHookData.Keys);
+        Assert.Contains("int", this._commonHookData.Keys);
+        Assert.Contains("string", this._commonHookData.Keys);
+    }
+
+    [Fact]
+    public void HookData_Has_Values()
+    {
+        Assert.Equal(5, this._commonHookData.Values.Count);
+        Assert.Contains(true, this._commonHookData.Values);
+        Assert.Contains(1, this._commonHookData.Values);
+        Assert.Contains(1.2f, this._commonHookData.Values);
+        Assert.Contains(1.2, this._commonHookData.Values);
+        Assert.Contains("string", this._commonHookData.Values);
+    }
+
+    [Fact]
+    public void HookData_Can_Be_Converted_To_Dictionary()
+    {
+        var asDictionary = this._commonHookData.AsDictionary();
+        Assert.Equal(5, asDictionary.Count);
+        Assert.Equal(true, asDictionary["bool"]);
+        Assert.Equal(1.2, asDictionary["double"]);
+        Assert.Equal(1.2f, asDictionary["float"]);
+        Assert.Equal(1, asDictionary["int"]);
+        Assert.Equal("string", asDictionary["string"]);
+    }
+
+    [Fact]
+    public void HookData_Get_Should_Throw_When_Key_Not_Found()
+    {
+        var hookData = new HookData();
+
+        Assert.Throws<KeyNotFoundException>(() => hookData.Get("nonexistent"));
+    }
+
+    [Fact]
+    public void HookData_Indexer_Should_Throw_When_Key_Not_Found()
+    {
+        var hookData = new HookData();
+
+        Assert.Throws<KeyNotFoundException>(() => _ = hookData["nonexistent"]);
+    }
+}
diff --git a/test/OpenFeature.Tests/OpenFeatureHookTests.cs b/test/OpenFeature.Tests/OpenFeatureHookTests.cs
index bbb4da3fd..ae53f6db4 100644
--- a/test/OpenFeature.Tests/OpenFeatureHookTests.cs
+++ b/test/OpenFeature.Tests/OpenFeatureHookTests.cs
@@ -90,7 +90,7 @@ await client.GetBooleanValueAsync(flagName, defaultValue, EvaluationContext.Empt
         }
 
         [Fact]
-        [Specification("4.1.1", "Hook context MUST provide: the `flag key`, `flag value type`, `evaluation context`, and the `default value`.")]
+        [Specification("4.1.1", "Hook context MUST provide: the `flag key`, `flag value type`, `evaluation context`, `default value`, and `hook data`.")]
         public void Hook_Context_Should_Not_Allow_Nulls()
         {
             Assert.Throws<ArgumentNullException>(() =>
@@ -108,6 +108,19 @@ public void Hook_Context_Should_Not_Allow_Nulls()
             Assert.Throws<ArgumentNullException>(() =>
                 new HookContext<Structure>("test", Structure.Empty, FlagValueType.Object, new ClientMetadata(null, null),
                     new Metadata(null), null));
+
+            Assert.Throws<ArgumentNullException>(() => new SharedHookContext<Structure>("test", Structure.Empty, FlagValueType.Object,
+                new ClientMetadata(null, null), new Metadata(null)).ToHookContext(null));
+
+            Assert.Throws<ArgumentNullException>(() =>
+                new HookContext<Structure>(null, EvaluationContext.Empty,
+                    new HookData()));
+
+            Assert.Throws<ArgumentNullException>(() =>
+                new HookContext<Structure>(
+                    new SharedHookContext<Structure>("test", Structure.Empty, FlagValueType.Object,
+                        new ClientMetadata(null, null), new Metadata(null)), EvaluationContext.Empty,
+                    null));
         }
 
         [Fact]
@@ -151,6 +164,95 @@ await client.GetBooleanValueAsync("test", false, EvaluationContext.Empty,
             _ = hook2.Received(1).BeforeAsync(Arg.Is<HookContext<bool>>(a => a.EvaluationContext.GetValue("test").AsString == "test"), Arg.Any<ImmutableDictionary<string, object>>());
         }
 
+        [Fact]
+        [Specification("4.1.5", "The `hook data` MUST be mutable.")]
+        public async Task HookData_Must_Be_Mutable()
+        {
+            var hook = Substitute.For<Hook>();
+
+            hook.BeforeAsync(Arg.Any<HookContext<bool>>(), Arg.Any<ImmutableDictionary<string, object>>())
+                .Returns(EvaluationContext.Empty).AndDoes(info =>
+                {
+                    info.Arg<HookContext<bool>>().Data.Set("test-a", true);
+                });
+            hook.AfterAsync(Arg.Any<HookContext<bool>>(), Arg.Any<FlagEvaluationDetails<bool>>(),
+                Arg.Any<ImmutableDictionary<string, object>>()).Returns(new ValueTask()).AndDoes(info =>
+            {
+                info.Arg<HookContext<bool>>().Data.Set("test-b", "test-value");
+            });
+
+            await Api.Instance.SetProviderAsync(new NoOpFeatureProvider());
+            var client = Api.Instance.GetClient("test", "1.0.0");
+
+            await client.GetBooleanValueAsync("test", false, EvaluationContext.Empty,
+                new FlagEvaluationOptions(ImmutableList.Create(hook), ImmutableDictionary<string, object>.Empty));
+
+            _ = hook.Received(1).AfterAsync(Arg.Is<HookContext<bool>>(hookContext =>
+                (bool)hookContext.Data.Get("test-a") == true
+            ), Arg.Any<FlagEvaluationDetails<bool>>(), Arg.Any<ImmutableDictionary<string, object>>());
+            _ = hook.Received(1).FinallyAsync(Arg.Is<HookContext<bool>>(hookContext =>
+                (bool)hookContext.Data.Get("test-a") == true && (string)hookContext.Data.Get("test-b") == "test-value"
+            ), Arg.Any<FlagEvaluationDetails<bool>>(), Arg.Any<ImmutableDictionary<string, object>>());
+        }
+
+        [Fact]
+        [Specification("4.3.2",
+            "`Hook data` **MUST** must be created before the first `stage` invoked in a hook for a specific evaluation and propagated between each `stage` of the hook. The hook data is not shared between different hooks.")]
+        public async Task HookData_Must_Be_Unique_Per_Hook()
+        {
+            var hook1 = Substitute.For<Hook>();
+            var hook2 = Substitute.For<Hook>();
+
+            hook1.BeforeAsync(Arg.Any<HookContext<bool>>(), Arg.Any<ImmutableDictionary<string, object>>())
+                .Returns(EvaluationContext.Empty).AndDoes(info =>
+                {
+                    info.Arg<HookContext<bool>>().Data.Set("hook-1-value-a", true);
+                    info.Arg<HookContext<bool>>().Data.Set("same", true);
+                });
+            hook1.AfterAsync(Arg.Any<HookContext<bool>>(), Arg.Any<FlagEvaluationDetails<bool>>(),
+                Arg.Any<ImmutableDictionary<string, object>>()).Returns(new ValueTask()).AndDoes(info =>
+            {
+                info.Arg<HookContext<bool>>().Data.Set("hook-1-value-b", "test-value-hook-1");
+            });
+
+            hook2.BeforeAsync(Arg.Any<HookContext<bool>>(), Arg.Any<ImmutableDictionary<string, object>>())
+                .Returns(EvaluationContext.Empty).AndDoes(info =>
+                {
+                    info.Arg<HookContext<bool>>().Data.Set("hook-2-value-a", false);
+                    info.Arg<HookContext<bool>>().Data.Set("same", false);
+                });
+            hook2.AfterAsync(Arg.Any<HookContext<bool>>(), Arg.Any<FlagEvaluationDetails<bool>>(),
+                Arg.Any<ImmutableDictionary<string, object>>()).Returns(new ValueTask()).AndDoes(info =>
+            {
+                info.Arg<HookContext<bool>>().Data.Set("hook-2-value-b", "test-value-hook-2");
+            });
+
+            await Api.Instance.SetProviderAsync(new NoOpFeatureProvider());
+            var client = Api.Instance.GetClient("test", "1.0.0");
+
+            await client.GetBooleanValueAsync("test", false, EvaluationContext.Empty,
+                new FlagEvaluationOptions(ImmutableList.Create(hook1, hook2),
+                    ImmutableDictionary<string, object>.Empty));
+
+            _ = hook1.Received(1).AfterAsync(Arg.Is<HookContext<bool>>(hookContext =>
+                (bool)hookContext.Data.Get("hook-1-value-a") == true && (bool)hookContext.Data.Get("same") == true
+            ), Arg.Any<FlagEvaluationDetails<bool>>(), Arg.Any<ImmutableDictionary<string, object>>());
+            _ = hook1.Received(1).FinallyAsync(Arg.Is<HookContext<bool>>(hookContext =>
+                (bool)hookContext.Data.Get("hook-1-value-a") == true &&
+                (bool)hookContext.Data.Get("same") == true &&
+                (string)hookContext.Data.Get("hook-1-value-b") == "test-value-hook-1" && hookContext.Data.Count == 3
+            ), Arg.Any<FlagEvaluationDetails<bool>>(), Arg.Any<ImmutableDictionary<string, object>>());
+
+            _ = hook2.Received(1).AfterAsync(Arg.Is<HookContext<bool>>(hookContext =>
+                (bool)hookContext.Data.Get("hook-2-value-a") == false && (bool)hookContext.Data.Get("same") == false
+            ), Arg.Any<FlagEvaluationDetails<bool>>(), Arg.Any<ImmutableDictionary<string, object>>());
+            _ = hook2.Received(1).FinallyAsync(Arg.Is<HookContext<bool>>(hookContext =>
+                (bool)hookContext.Data.Get("hook-2-value-a") == false &&
+                (bool)hookContext.Data.Get("same") == false &&
+                (string)hookContext.Data.Get("hook-2-value-b") == "test-value-hook-2" && hookContext.Data.Count == 3
+            ), Arg.Any<FlagEvaluationDetails<bool>>(), Arg.Any<ImmutableDictionary<string, object>>());
+        }
+
         [Fact]
         [Specification("3.2.2", "Evaluation context MUST be merged in the order: API (global; lowest precedence) - client - invocation - before hooks (highest precedence), with duplicate values being overwritten.")]
         [Specification("4.3.4", "When `before` hooks have finished executing, any resulting `evaluation context` MUST be merged with the existing `evaluation context`.")]
@@ -394,7 +496,7 @@ public async Task Error_Hook_Should_Be_Executed_Even_If_Abnormal_Termination()
             hook1.BeforeAsync(Arg.Any<HookContext<bool>>(), null).Returns(EvaluationContext.Empty);
             hook2.BeforeAsync(Arg.Any<HookContext<bool>>(), null).Returns(EvaluationContext.Empty);
             featureProvider1.ResolveBooleanValueAsync(Arg.Any<string>(), Arg.Any<bool>(), Arg.Any<EvaluationContext>()).Throws(new Exception());
-            hook2.ErrorAsync(Arg.Any<HookContext<bool>>(), Arg.Any<Exception>(), null).Returns(new ValueTask());
+            hook2.ErrorAsync(Arg.Any<HookContext<bool>>(), Arg.Any<Exception>(), null).Throws(new Exception());
             hook1.ErrorAsync(Arg.Any<HookContext<bool>>(), Arg.Any<Exception>(), null).Returns(new ValueTask());
 
             await Api.Instance.SetProviderAsync(featureProvider1);