@@ -534,6 +534,9 @@ def __init__(
             data_converter: DataConverter | None = None,
     ):
         self._registry = _Registry()
+        # Shared by every entity batch this worker processes so that reflected
+        # entity method signatures are computed once instead of per operation.
+        self._entity_method_cache = _EntityMethodSignatureCache()
         self._host_address = (
             host_address if host_address else shared.get_default_host_address()
         )
@@ -1370,9 +1373,17 @@ def _execute_entity_batch(
             raise RuntimeError(f"Invalid entity instance ID '{instance_id}' in entity operation request.")
 
         results: list[pb.OperationResult] = []
+        # A single executor serves the whole batch and shares the worker's
+        # bounded signature cache, so entity method reflection is not repeated
+        # for every operation.
+        executor = _EntityExecutor(
+            self._registry,
+            self._logger,
+            self._data_converter,
+            entity_method_cache=self._entity_method_cache,
+        )
         for operation in req.operations:
             start_time = datetime.now(timezone.utc)
-            executor = _EntityExecutor(self._registry, self._logger, self._data_converter)
 
             operation_result = None
 
@@ -3101,13 +3112,61 @@ def execute(
         return encoded_output
 
 
+class _EntityMethodSignatureCache:
+    """Bounded, thread-safe cache of reflected entity method signatures.
+
+    Dispatching an operation on a class-based entity requires knowing whether
+    the target method declares a required parameter, which is answered with an
+    ``inspect.signature()`` call. The answer depends only on the entity type
+    and the operation name, so it is cached here and shared across entity
+    batches (and therefore across the worker threads that process them
+    concurrently).
+
+    The cache is bounded because entity types and operation names originate
+    from user code and are unbounded in principle; once the limit is reached
+    the oldest entries are evicted instead of growing without limit.
+    """
+
+    DEFAULT_MAX_SIZE = 1024
+
+    def __init__(self, max_size: int = DEFAULT_MAX_SIZE):
+        self._max_size = max(1, max_size)
+        self._lock = Lock()
+        self._entries: dict[tuple[type, str], bool] = {}
+
+    def get(self, key: tuple[type, str]) -> bool | None:
+        """Returns the cached result for ``key``, or ``None`` when not cached."""
+        return self._entries.get(key)
+
+    def __setitem__(self, key: tuple[type, str], value: bool) -> None:
+        with self._lock:
+            self._entries[key] = value
+            # Dicts preserve insertion order, so the first key is the oldest.
+            while len(self._entries) > self._max_size:
+                self._entries.pop(next(iter(self._entries)), None)
+
+    def __contains__(self, key: object) -> bool:
+        return key in self._entries
+
+    def __len__(self) -> int:
+        return len(self._entries)
+
+
 class _EntityExecutor:
     def __init__(self, registry: _Registry, logger: logging.Logger,
-                 data_converter: DataConverter):
+                 data_converter: DataConverter,
+                 entity_method_cache: _EntityMethodSignatureCache | None = None):
         self._registry = registry
         self._logger = logger
         self._data_converter = data_converter
-        self._entity_method_cache: dict[tuple[type, str], bool] = {}
+        # When the caller supplies a cache (the worker does), reflected entity
+        # method signatures are shared with it and therefore survive beyond the
+        # lifetime of this executor.
+        self._entity_method_cache: _EntityMethodSignatureCache = (
+            entity_method_cache
+            if entity_method_cache is not None
+            else _EntityMethodSignatureCache()
+        )
 
     def execute(
             self,
 
@@ -2,13 +2,23 @@
 # Licensed under the MIT License.
 
 """Unit tests for the _EntityExecutor class in durabletask.worker."""
+import inspect
 import json
 import logging
+import threading
 
-from durabletask import entities
+from google.protobuf import wrappers_pb2
+
+import durabletask.internal.orchestrator_service_pb2 as pb
+from durabletask import entities, worker
 from durabletask.internal.entity_state_shim import StateShim
 from durabletask.serialization import JsonDataConverter
-from durabletask.worker import _EntityExecutor, _Registry
+from durabletask.worker import (
+    TaskHubGrpcWorker,
+    _EntityExecutor,
+    _EntityMethodSignatureCache,
+    _Registry,
+)
 
 
 def _make_executor(*entity_args) -> _EntityExecutor:
@@ -289,3 +299,227 @@ def test_falsy_serialized_state_is_not_dropped(self):
         state = StateShim("0", JsonDataConverter(), is_serialized=True)
         assert state.get_state(int) == 0
         assert state.encode_state() == "0"
+
+
+class _CountingInspect:
+    """Delegates to :mod:`inspect` while counting ``signature()`` calls."""
+
+    def __init__(self):
+        self.signature_calls: list[object] = []
+
+    def signature(self, obj, *args, **kwargs):
+        self.signature_calls.append(obj)
+        return inspect.signature(obj, *args, **kwargs)
+
+    def __getattr__(self, name):
+        return getattr(inspect, name)
+
+
+class _RecordingEntityStub:
+    """Captures the batch results the worker would send to the sidecar."""
+
+    def __init__(self):
+        self.completed: list[pb.EntityBatchResult] = []
+
+    def CompleteEntityTask(self, batch_result):
+        self.completed.append(batch_result)
+
+
+def _entity_batch_request(instance_id: str, operations) -> pb.EntityBatchRequest:
+    """Builds an entity batch request from (operation, encoded_input) pairs."""
+    return pb.EntityBatchRequest(
+        instanceId=instance_id,
+        operations=[
+            pb.OperationRequest(
+                operation=name,
+                requestId=str(index),
+                input=(
+                    wrappers_pb2.StringValue(value=encoded_input)
+                    if encoded_input is not None
+                    else None
+                ),
+            )
+            for index, (name, encoded_input) in enumerate(operations)
+        ],
+    )
+
+
+class Counter(entities.DurableEntity):
+    """Entity exercising both input-argument and no-argument dispatch."""
+
+    def add(self, value: int):
+        current = self.get_state(int, 0)
+        self.set_state(current + value)
+        return current + value
+
+    def get(self):
+        return self.get_state(int, 0)
+
+
+class TestEntityMethodSignatureCaching:
+    """Reflection of an entity method signature must happen only once."""
+
+    def test_repeated_operations_reflect_once_per_executor(self, monkeypatch):
+        executor = _make_executor(Counter)
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        entity_id = entities.EntityInstanceId("Counter", "test-key")
+        state = StateShim(None, JsonDataConverter())
+        for _ in range(5):
+            executor.execute("test-orch", entity_id, "add", state, "1")
+            state.commit()
+
+        assert len(counting.signature_calls) == 1
+        assert state.get_state(int) == 5
+
+    def test_cache_is_shared_between_executors(self, monkeypatch):
+        shared_cache = _EntityMethodSignatureCache()
+        registry = _Registry()
+        registry.add_entity(Counter)
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        entity_id = entities.EntityInstanceId("Counter", "test-key")
+        for _ in range(3):
+            executor = _EntityExecutor(
+                registry, logging.getLogger("test"), JsonDataConverter(),
+                entity_method_cache=shared_cache,
+            )
+            executor.execute(
+                "test-orch", entity_id, "add",
+                StateShim(None, JsonDataConverter()), "1")
+
+        assert len(counting.signature_calls) == 1
+
+    def test_executor_without_shared_cache_still_caches(self, monkeypatch):
+        # Constructing the executor with the historical three-argument form
+        # keeps working and still avoids repeated reflection.
+        registry = _Registry()
+        registry.add_entity(Counter)
+        executor = _EntityExecutor(
+            registry, logging.getLogger("test"), JsonDataConverter())
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        entity_id = entities.EntityInstanceId("Counter", "test-key")
+        state = StateShim(None, JsonDataConverter())
+        executor.execute("test-orch", entity_id, "add", state, "1")
+        executor.execute("test-orch", entity_id, "add", state, "1")
+
+        assert len(counting.signature_calls) == 1
+
+
+class TestEntityBatchSignatureCaching:
+    """The worker must not recompute signatures for every batch operation."""
+
+    @staticmethod
+    def _make_worker() -> TaskHubGrpcWorker:
+        instance = TaskHubGrpcWorker()
+        instance.add_entity(Counter)
+        return instance
+
+    def test_batch_reflects_once_for_repeated_operations(self, monkeypatch):
+        instance = self._make_worker()
+        stub = _RecordingEntityStub()
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        request = _entity_batch_request("@counter@key", [("add", "1")] * 5)
+        result = instance._execute_entity_batch(request, stub, b"token")
+
+        assert [r.WhichOneof("resultType") for r in result.results] == ["success"] * 5
+        assert json.loads(result.entityState.value) == 5
+        assert len(counting.signature_calls) == 1
+        assert len(stub.completed) == 1
+
+    def test_cache_survives_across_batches(self, monkeypatch):
+        instance = self._make_worker()
+        stub = _RecordingEntityStub()
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        for _ in range(3):
+            instance._execute_entity_batch(
+                _entity_batch_request("@counter@key", [("add", "1")]), stub, b"token")
+
+        assert len(counting.signature_calls) == 1
+
+    def test_worker_cache_is_populated_by_batch(self):
+        instance = self._make_worker()
+        instance._execute_entity_batch(
+            _entity_batch_request("@counter@key", [("add", "1")]),
+            _RecordingEntityStub(), b"token")
+
+        assert (Counter, "add") in instance._entity_method_cache
+
+    def test_no_arg_and_input_arg_dispatch_preserved(self, monkeypatch):
+        instance = self._make_worker()
+        stub = _RecordingEntityStub()
+        counting = _CountingInspect()
+        monkeypatch.setattr(worker, "inspect", counting)
+
+        request = _entity_batch_request(
+            "@counter@key",
+            [("add", "2"), ("get", None), ("add", "3"), ("get", None)],
+        )
+        result = instance._execute_entity_batch(request, stub, b"token")
+
+        assert [r.success.result.value for r in result.results] == ["2", "2", "5", "5"]
+        # One reflection per distinct operation, regardless of repeat count.
+        assert len(counting.signature_calls) == 2
+
+    def test_unknown_operation_failure_is_unchanged(self):
+        instance = self._make_worker()
+        result = instance._execute_entity_batch(
+            _entity_batch_request("@counter@key", [("missing", None)]),
+            _RecordingEntityStub(), b"token")
+
+        failure = result.results[0]
+        assert failure.WhichOneof("resultType") == "failure"
+        details = failure.failure.failureDetails
+        assert details.errorType == "builtins.AttributeError"
+        assert "does not have operation 'missing'" in details.errorMessage
+
+
+class TestEntityMethodSignatureCacheBounds:
+    """The shared signature cache must stay bounded and thread-safe."""
+
+    def test_get_returns_none_for_unknown_key(self):
+        cache = _EntityMethodSignatureCache()
+        assert cache.get((int, "missing")) is None
+
+    def test_false_values_are_distinguishable_from_misses(self):
+        cache = _EntityMethodSignatureCache()
+        cache[(int, "op")] = False
+        assert cache.get((int, "op")) is False
+        assert (int, "op") in cache
+
+    def test_evicts_oldest_entries_when_full(self):
+        cache = _EntityMethodSignatureCache(max_size=2)
+        cache[(int, "op")] = True
+        cache[(str, "op")] = True
+        cache[(float, "op")] = True
+
+        assert len(cache) == 2
+        assert cache.get((int, "op")) is None
+        assert cache.get((str, "op")) is True
+        assert cache.get((float, "op")) is True
+
+    def test_concurrent_writes_stay_within_bound(self):
+        cache = _EntityMethodSignatureCache(max_size=8)
+        entity_types = [type(f"Entity{index}", (), {}) for index in range(64)]
+        barrier = threading.Barrier(4)
+
+        def writer(worker_index: int) -> None:
+            barrier.wait()
+            for index, entity_type in enumerate(entity_types):
+                cache[(entity_type, f"op{worker_index}")] = index % 2 == 0
+
+        threads = [threading.Thread(target=writer, args=(index,)) for index in range(4)]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join()
+
+        assert len(cache) == 8