diff --git a/chasm/lib/activity/activity.go b/chasm/lib/activity/activity.go
index 286078d089..c8609419ba 100644
--- a/chasm/lib/activity/activity.go
+++ b/chasm/lib/activity/activity.go
@@ -76,21 +76,18 @@ func NewStandaloneActivity(
 	visibility := chasm.NewVisibilityWithData(
 		ctx,
 		request.GetSearchAttributes().GetIndexedFields(),
-		request.GetMemo().GetFields(),
+		nil,
 	)
 
-	// TODO flatten this when API is updated
-	options := request.GetOptions()
-
 	activity := &Activity{
 		ActivityState: &activitypb.ActivityState{
 			ActivityType:           request.ActivityType,
-			TaskQueue:              options.GetTaskQueue(),
-			ScheduleToCloseTimeout: options.GetScheduleToCloseTimeout(),
-			ScheduleToStartTimeout: options.GetScheduleToStartTimeout(),
-			StartToCloseTimeout:    options.GetStartToCloseTimeout(),
-			HeartbeatTimeout:       options.GetHeartbeatTimeout(),
-			RetryPolicy:            options.GetRetryPolicy(),
+			TaskQueue:              request.GetTaskQueue(),
+			ScheduleToCloseTimeout: request.GetScheduleToCloseTimeout(),
+			ScheduleToStartTimeout: request.GetScheduleToStartTimeout(),
+			StartToCloseTimeout:    request.GetStartToCloseTimeout(),
+			HeartbeatTimeout:       request.GetHeartbeatTimeout(),
+			RetryPolicy:            request.GetRetryPolicy(),
 			Priority:               request.Priority,
 		},
 		LastAttempt: chasm.NewDataField(ctx, &activitypb.ActivityAttemptState{}),
@@ -103,7 +100,7 @@ func NewStandaloneActivity(
 		Visibility: chasm.NewComponentField(ctx, visibility),
 	}
 
-	activity.ScheduledTime = timestamppb.New(ctx.Now(activity))
+	activity.ScheduleTime = timestamppb.New(ctx.Now(activity))
 
 	return activity, nil
 }
@@ -355,7 +352,6 @@ func (a *Activity) recordFailedAttempt(
 	failure *failurepb.Failure,
 	noRetriesLeft bool,
 ) error {
-	outcome := a.Outcome.Get(ctx)
 	attempt := a.LastAttempt.Get(ctx)
 	currentTime := timestamppb.New(ctx.Now(a))
 
@@ -368,7 +364,6 @@ func (a *Activity) recordFailedAttempt(
 	// If the activity has exhausted retries, mark the outcome failure as well but don't store duplicate failure info.
 	// Also reset the retry interval as there won't be any more retries.
 	if noRetriesLeft {
-		outcome.Variant = &activitypb.ActivityOutcome_Failed_{}
 		attempt.CurrentRetryInterval = nil
 	} else {
 		attempt.CurrentRetryInterval = durationpb.New(retryInterval)
@@ -407,7 +402,7 @@ func (a *Activity) hasEnoughTimeForRetry(ctx chasm.Context, overridingRetryInter
 		return true, retryInterval, nil
 	}
 
-	deadline := a.ScheduledTime.AsTime().Add(scheduleToClose)
+	deadline := a.ScheduleTime.AsTime().Add(scheduleToClose)
 	return ctx.Now(a).Add(retryInterval).Before(deadline), retryInterval, nil
 }
 
@@ -486,7 +481,7 @@ func (a *Activity) buildActivityExecutionInfo(ctx chasm.Context) (*activity.Acti
 		Priority:                a.GetPriority(),
 		RunId:                   key.RunID,
 		RunState:                runState,
-		ScheduledTime:           a.GetScheduledTime(),
+		ScheduleTime:            a.GetScheduleTime(),
 		Status:                  status,
 		// TODO(dan): populate remaining fields
 	}
@@ -494,10 +489,10 @@ func (a *Activity) buildActivityExecutionInfo(ctx chasm.Context) (*activity.Acti
 	return info, nil
 }
 
-func (a *Activity) buildPollActivityExecutionResponse(
+func (a *Activity) buildDescribeActivityExecutionResponse(
 	ctx chasm.Context,
-	req *activitypb.PollActivityExecutionRequest,
-) (*activitypb.PollActivityExecutionResponse, error) {
+	req *activitypb.DescribeActivityExecutionRequest,
+) (*activitypb.DescribeActivityExecutionResponse, error) {
 	request := req.GetFrontendRequest()
 
 	token, err := ctx.Ref(a)
@@ -505,64 +500,77 @@ func (a *Activity) buildPollActivityExecutionResponse(
 		return nil, err
 	}
 
-	var info *activity.ActivityExecutionInfo
-	if request.GetIncludeInfo() {
-		info, err = a.buildActivityExecutionInfo(ctx)
-		if err != nil {
-			return nil, err
-		}
+	info, err := a.buildActivityExecutionInfo(ctx)
+	if err != nil {
+		return nil, err
 	}
 
 	var input *commonpb.Payloads
 	if request.GetIncludeInput() {
-		activityRequest := a.RequestData.Get(ctx)
-		input = activityRequest.GetInput()
+		input = a.RequestData.Get(ctx).GetInput()
 	}
 
-	response := &workflowservice.PollActivityExecutionResponse{
-		Info:                     info,
-		RunId:                    ctx.ExecutionKey().RunID,
-		Input:                    input,
-		StateChangeLongPollToken: token,
+	response := &workflowservice.DescribeActivityExecutionResponse{
+		Info:          info,
+		RunId:         ctx.ExecutionKey().RunID,
+		Input:         input,
+		LongPollToken: token,
 	}
 
 	if request.GetIncludeOutcome() {
-		activityOutcome := a.Outcome.Get(ctx)
-		// There are two places where a failure might be stored but only one place where a
-		// successful outcome is stored.
-		if successful := activityOutcome.GetSuccessful(); successful != nil {
-			response.Outcome = &workflowservice.PollActivityExecutionResponse_Result{
-				Result: successful.GetOutput(),
-			}
-		} else if failure := activityOutcome.GetFailed().GetFailure(); failure != nil {
-			response.Outcome = &workflowservice.PollActivityExecutionResponse_Failure{
-				Failure: failure,
-			}
-		} else {
-			shouldHaveFailure := (a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_FAILED ||
-				a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_TIMED_OUT ||
-				a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_CANCELED ||
-				a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_TERMINATED)
-
-			if shouldHaveFailure {
-				attempt := a.LastAttempt.Get(ctx)
-				if details := attempt.GetLastFailureDetails(); details != nil {
-					response.Outcome = &workflowservice.PollActivityExecutionResponse_Failure{
-						Failure: details.GetFailure(),
-					}
-				}
-			}
-		}
+		response.Outcome = a.outcome(ctx)
 	}
 
-	return &activitypb.PollActivityExecutionResponse{
+	return &activitypb.DescribeActivityExecutionResponse{
 		FrontendResponse: response,
 	}, nil
 }
 
-// StoreOrSelf returns the store for the activity. If the store is not set as a field (e.g. standalone
-// activities), it returns the activity itself.
-func (a *Activity) StoreOrSelf(ctx chasm.MutableContext) ActivityStore {
+func (a *Activity) buildGetActivityExecutionOutcomeResponse(
+	ctx chasm.Context,
+) (*activitypb.GetActivityExecutionOutcomeResponse, error) {
+	return &activitypb.GetActivityExecutionOutcomeResponse{
+		FrontendResponse: &workflowservice.GetActivityExecutionOutcomeResponse{
+			RunId:   ctx.ExecutionKey().RunID,
+			Outcome: a.outcome(ctx),
+		},
+	}, nil
+}
+
+// outcome retrieves the activity outcome (result or failure) if the activity has completed.
+// Returns nil if the activity has not completed.
+func (a *Activity) outcome(ctx chasm.Context) *activity.ActivityExecutionOutcome {
+	activityOutcome := a.Outcome.Get(ctx)
+	// Check for successful outcome
+	if successful := activityOutcome.GetSuccessful(); successful != nil {
+		return &activity.ActivityExecutionOutcome{
+			Value: &activity.ActivityExecutionOutcome_Result{Result: successful.GetOutput()},
+		}
+	}
+	// Check for failure in outcome
+	if failure := activityOutcome.GetFailed().GetFailure(); failure != nil {
+		return &activity.ActivityExecutionOutcome{
+			Value: &activity.ActivityExecutionOutcome_Failure{Failure: failure},
+		}
+	}
+	// Check for failure in last attempt details
+	shouldHaveFailure := (a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_FAILED ||
+		a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_TIMED_OUT ||
+		a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_CANCELED ||
+		a.GetStatus() == activitypb.ACTIVITY_EXECUTION_STATUS_TERMINATED)
+	if shouldHaveFailure {
+		if details := a.LastAttempt.Get(ctx).GetLastFailureDetails(); details != nil {
+			return &activity.ActivityExecutionOutcome{
+				Value: &activity.ActivityExecutionOutcome_Failure{Failure: details.GetFailure()},
+			}
+		}
+	}
+	return nil
+}
+
+// StoreOrSelf returns the store for the activity. If the store is not set as a field (e.g.
+// standalone activities), it returns the activity itself.
+func (a *Activity) StoreOrSelf(ctx chasm.Context) ActivityStore {
 	store, ok := a.Store.TryGet(ctx)
 	if ok {
 		return store
diff --git a/chasm/lib/activity/frontend.go b/chasm/lib/activity/frontend.go
index 39d469e040..300b6bdd47 100644
--- a/chasm/lib/activity/frontend.go
+++ b/chasm/lib/activity/frontend.go
@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/google/uuid"
+	apiactivitypb "go.temporal.io/api/activity/v1" //nolint:importas
 	commonpb "go.temporal.io/api/common/v1"
 	"go.temporal.io/api/serviceerror"
 	"go.temporal.io/api/workflowservice/v1"
@@ -19,9 +20,10 @@ import (
 
 type FrontendHandler interface {
 	StartActivityExecution(ctx context.Context, req *workflowservice.StartActivityExecutionRequest) (*workflowservice.StartActivityExecutionResponse, error)
+	DescribeActivityExecution(ctx context.Context, req *workflowservice.DescribeActivityExecutionRequest) (*workflowservice.DescribeActivityExecutionResponse, error)
+	GetActivityExecutionOutcome(ctx context.Context, req *workflowservice.GetActivityExecutionOutcomeRequest) (*workflowservice.GetActivityExecutionOutcomeResponse, error)
 	CountActivityExecutions(context.Context, *workflowservice.CountActivityExecutionsRequest) (*workflowservice.CountActivityExecutionsResponse, error)
 	DeleteActivityExecution(context.Context, *workflowservice.DeleteActivityExecutionRequest) (*workflowservice.DeleteActivityExecutionResponse, error)
-	PollActivityExecution(context.Context, *workflowservice.PollActivityExecutionRequest) (*workflowservice.PollActivityExecutionResponse, error)
 	ListActivityExecutions(context.Context, *workflowservice.ListActivityExecutionsRequest) (*workflowservice.ListActivityExecutionsResponse, error)
 	RequestCancelActivityExecution(context.Context, *workflowservice.RequestCancelActivityExecutionRequest) (*workflowservice.RequestCancelActivityExecutionResponse, error)
 	TerminateActivityExecution(context.Context, *workflowservice.TerminateActivityExecutionRequest) (*workflowservice.TerminateActivityExecutionResponse, error)
@@ -87,14 +89,13 @@ func (h *frontendHandler) StartActivityExecution(ctx context.Context, req *workf
 	return resp.GetFrontendResponse(), err
 }
 
-// PollActivityExecution handles PollActivityExecutionRequest. This method supports querying current
-// activity state, optionally as a long-poll that waits for certain state changes. It is used by
-// clients to poll for activity state and/or result.
-func (h *frontendHandler) PollActivityExecution(
+// DescribeActivityExecution queries current activity state, optionally as a long-poll that waits
+// for any state change.
+func (h *frontendHandler) DescribeActivityExecution(
 	ctx context.Context,
-	req *workflowservice.PollActivityExecutionRequest,
-) (*workflowservice.PollActivityExecutionResponse, error) {
-	err := ValidatePollActivityExecutionRequest(
+	req *workflowservice.DescribeActivityExecutionRequest,
+) (*workflowservice.DescribeActivityExecutionResponse, error) {
+	err := ValidateDescribeActivityExecutionRequest(
 		req,
 		dynamicconfig.MaxIDLengthLimit.Get(h.dc)(),
 	)
@@ -106,7 +107,31 @@ func (h *frontendHandler) PollActivityExecution(
 	if err != nil {
 		return nil, err
 	}
-	resp, err := h.client.PollActivityExecution(ctx, &activitypb.PollActivityExecutionRequest{
+
+	resp, err := h.client.DescribeActivityExecution(ctx, &activitypb.DescribeActivityExecutionRequest{
+		NamespaceId:     namespaceID.String(),
+		FrontendRequest: req,
+	})
+	return resp.GetFrontendResponse(), err
+}
+
+// GetActivityExecutionOutcome long-polls for activity outcome.
+func (h *frontendHandler) GetActivityExecutionOutcome(
+	ctx context.Context,
+	req *workflowservice.GetActivityExecutionOutcomeRequest,
+) (*workflowservice.GetActivityExecutionOutcomeResponse, error) {
+	err := ValidateGetActivityExecutionOutcomeRequest(
+		req,
+		dynamicconfig.MaxIDLengthLimit.Get(h.dc)(),
+	)
+	if err != nil {
+		return nil, err
+	}
+	namespaceID, err := h.namespaceRegistry.GetNamespaceID(namespace.Name(req.GetNamespace()))
+	if err != nil {
+		return nil, err
+	}
+	resp, err := h.client.GetActivityExecutionOutcome(ctx, &activitypb.GetActivityExecutionOutcomeRequest{
 		NamespaceId:     namespaceID.String(),
 		FrontendRequest: req,
 	})
@@ -193,23 +218,25 @@ func (h *frontendHandler) validateAndPopulateStartRequest(
 	req = common.CloneProto(req)
 	activityType := req.ActivityType.GetName()
 
-	if req.Options.RetryPolicy == nil {
-		req.Options.RetryPolicy = &commonpb.RetryPolicy{}
+	if req.RetryPolicy == nil {
+		req.RetryPolicy = &commonpb.RetryPolicy{}
 	}
 
+	opts := activityOptionsFromStartRequest(req)
 	err := ValidateAndNormalizeActivityAttributes(
 		req.ActivityId,
 		activityType,
 		dynamicconfig.DefaultActivityRetryPolicy.Get(h.dc),
 		dynamicconfig.MaxIDLengthLimit.Get(h.dc)(),
 		namespaceID,
-		req.Options,
+		opts,
 		req.Priority,
 		durationpb.New(0),
 	)
 	if err != nil {
 		return nil, err
 	}
+	applyActivityOptionsToStartRequest(opts, req)
 
 	err = validateAndNormalizeStartActivityExecutionRequest(
 		req,
@@ -224,3 +251,27 @@ func (h *frontendHandler) validateAndPopulateStartRequest(
 
 	return req, nil
 }
+
+// activityOptionsFromStartRequest builds an ActivityOptions from the inlined fields
+// of a StartActivityExecutionRequest for use with shared validation logic.
+func activityOptionsFromStartRequest(req *workflowservice.StartActivityExecutionRequest) *apiactivitypb.ActivityOptions {
+	return &apiactivitypb.ActivityOptions{
+		TaskQueue:              req.TaskQueue,
+		ScheduleToCloseTimeout: req.ScheduleToCloseTimeout,
+		ScheduleToStartTimeout: req.ScheduleToStartTimeout,
+		StartToCloseTimeout:    req.StartToCloseTimeout,
+		HeartbeatTimeout:       req.HeartbeatTimeout,
+		RetryPolicy:            req.RetryPolicy,
+	}
+}
+
+// applyActivityOptionsToStartRequest copies normalized values from ActivityOptions
+// back to the StartActivityExecutionRequest.
+func applyActivityOptionsToStartRequest(opts *apiactivitypb.ActivityOptions, req *workflowservice.StartActivityExecutionRequest) {
+	req.TaskQueue = opts.TaskQueue
+	req.ScheduleToCloseTimeout = opts.ScheduleToCloseTimeout
+	req.ScheduleToStartTimeout = opts.ScheduleToStartTimeout
+	req.StartToCloseTimeout = opts.StartToCloseTimeout
+	req.HeartbeatTimeout = opts.HeartbeatTimeout
+	req.RetryPolicy = opts.RetryPolicy
+}
diff --git a/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go b/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go
index 5d47d4f555..bd5ca89dc0 100644
--- a/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go
+++ b/chasm/lib/activity/gen/activitypb/v1/activity_state.pb.go
@@ -177,7 +177,7 @@ type ActivityState struct {
 	// components on each attempt transition.
 	Status ActivityExecutionStatus `protobuf:"varint,8,opt,name=status,proto3,enum=temporal.server.chasm.lib.activity.proto.v1.ActivityExecutionStatus" json:"status,omitempty"`
 	// Time the activity was originally scheduled via a StartActivityExecution request.
-	ScheduledTime *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=scheduled_time,json=scheduledTime,proto3" json:"scheduled_time,omitempty"`
+	ScheduleTime *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=schedule_time,json=scheduleTime,proto3" json:"schedule_time,omitempty"`
 	// Priority metadata.
 	Priority *v1.Priority `protobuf:"bytes,10,opt,name=priority,proto3" json:"priority,omitempty"`
 	// Set if activity cancelation was requested.
@@ -272,9 +272,9 @@ func (x *ActivityState) GetStatus() ActivityExecutionStatus {
 	return ACTIVITY_EXECUTION_STATUS_UNSPECIFIED
 }
 
-func (x *ActivityState) GetScheduledTime() *timestamppb.Timestamp {
+func (x *ActivityState) GetScheduleTime() *timestamppb.Timestamp {
 	if x != nil {
-		return x.ScheduledTime
+		return x.ScheduleTime
 	}
 	return nil
 }
@@ -815,7 +815,7 @@ var File_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto protor
 
 const file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawDesc = "" +
 	"\n" +
-	"@temporal/server/chasm/lib/activity/proto/v1/activity_state.proto\x12+temporal.server.chasm.lib.activity.proto.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a$temporal/api/common/v1/message.proto\x1a(temporal/api/deployment/v1/message.proto\x1a%temporal/api/failure/v1/message.proto\x1a'temporal/api/sdk/v1/user_metadata.proto\x1a'temporal/api/taskqueue/v1/message.proto\"\xef\x06\n" +
+	"@temporal/server/chasm/lib/activity/proto/v1/activity_state.proto\x12+temporal.server.chasm.lib.activity.proto.v1\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\x1a$temporal/api/common/v1/message.proto\x1a(temporal/api/deployment/v1/message.proto\x1a%temporal/api/failure/v1/message.proto\x1a'temporal/api/sdk/v1/user_metadata.proto\x1a'temporal/api/taskqueue/v1/message.proto\"\xed\x06\n" +
 	"\rActivityState\x12I\n" +
 	"\ractivity_type\x18\x01 \x01(\v2$.temporal.api.common.v1.ActivityTypeR\factivityType\x12C\n" +
 	"\n" +
@@ -825,8 +825,8 @@ const file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_rawD
 	"\x16start_to_close_timeout\x18\x05 \x01(\v2\x19.google.protobuf.DurationR\x13startToCloseTimeout\x12F\n" +
 	"\x11heartbeat_timeout\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\x10heartbeatTimeout\x12F\n" +
 	"\fretry_policy\x18\a \x01(\v2#.temporal.api.common.v1.RetryPolicyR\vretryPolicy\x12\\\n" +
-	"\x06status\x18\b \x01(\x0e2D.temporal.server.chasm.lib.activity.proto.v1.ActivityExecutionStatusR\x06status\x12A\n" +
-	"\x0escheduled_time\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\rscheduledTime\x12<\n" +
+	"\x06status\x18\b \x01(\x0e2D.temporal.server.chasm.lib.activity.proto.v1.ActivityExecutionStatusR\x06status\x12?\n" +
+	"\rschedule_time\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\fscheduleTime\x12<\n" +
 	"\bpriority\x18\n" +
 	" \x01(\v2 .temporal.api.common.v1.PriorityR\bpriority\x12c\n" +
 	"\fcancel_state\x18\v \x01(\v2@.temporal.server.chasm.lib.activity.proto.v1.ActivityCancelStateR\vcancelState\"\xa7\x01\n" +
@@ -922,7 +922,7 @@ var file_temporal_server_chasm_lib_activity_proto_v1_activity_state_proto_depIdx
 	12, // 5: temporal.server.chasm.lib.activity.proto.v1.ActivityState.heartbeat_timeout:type_name -> google.protobuf.Duration
 	13, // 6: temporal.server.chasm.lib.activity.proto.v1.ActivityState.retry_policy:type_name -> temporal.api.common.v1.RetryPolicy
 	0,  // 7: temporal.server.chasm.lib.activity.proto.v1.ActivityState.status:type_name -> temporal.server.chasm.lib.activity.proto.v1.ActivityExecutionStatus
-	14, // 8: temporal.server.chasm.lib.activity.proto.v1.ActivityState.scheduled_time:type_name -> google.protobuf.Timestamp
+	14, // 8: temporal.server.chasm.lib.activity.proto.v1.ActivityState.schedule_time:type_name -> google.protobuf.Timestamp
 	15, // 9: temporal.server.chasm.lib.activity.proto.v1.ActivityState.priority:type_name -> temporal.api.common.v1.Priority
 	2,  // 10: temporal.server.chasm.lib.activity.proto.v1.ActivityState.cancel_state:type_name -> temporal.server.chasm.lib.activity.proto.v1.ActivityCancelState
 	14, // 11: temporal.server.chasm.lib.activity.proto.v1.ActivityCancelState.request_time:type_name -> google.protobuf.Timestamp
diff --git a/chasm/lib/activity/gen/activitypb/v1/request_response.go-helpers.pb.go b/chasm/lib/activity/gen/activitypb/v1/request_response.go-helpers.pb.go
index 12ecdc4739..ac2e0161ba 100644
--- a/chasm/lib/activity/gen/activitypb/v1/request_response.go-helpers.pb.go
+++ b/chasm/lib/activity/gen/activitypb/v1/request_response.go-helpers.pb.go
@@ -79,35 +79,35 @@ func (this *StartActivityExecutionResponse) Equal(that interface{}) bool {
 	return proto.Equal(this, that1)
 }
 
-// Marshal an object of type PollActivityExecutionRequest to the protobuf v3 wire format
-func (val *PollActivityExecutionRequest) Marshal() ([]byte, error) {
+// Marshal an object of type DescribeActivityExecutionRequest to the protobuf v3 wire format
+func (val *DescribeActivityExecutionRequest) Marshal() ([]byte, error) {
 	return proto.Marshal(val)
 }
 
-// Unmarshal an object of type PollActivityExecutionRequest from the protobuf v3 wire format
-func (val *PollActivityExecutionRequest) Unmarshal(buf []byte) error {
+// Unmarshal an object of type DescribeActivityExecutionRequest from the protobuf v3 wire format
+func (val *DescribeActivityExecutionRequest) Unmarshal(buf []byte) error {
 	return proto.Unmarshal(buf, val)
 }
 
 // Size returns the size of the object, in bytes, once serialized
-func (val *PollActivityExecutionRequest) Size() int {
+func (val *DescribeActivityExecutionRequest) Size() int {
 	return proto.Size(val)
 }
 
-// Equal returns whether two PollActivityExecutionRequest values are equivalent by recursively
+// Equal returns whether two DescribeActivityExecutionRequest values are equivalent by recursively
 // comparing the message's fields.
 // For more information see the documentation for
 // https://pkg.go.dev/google.golang.org/protobuf/proto#Equal
-func (this *PollActivityExecutionRequest) Equal(that interface{}) bool {
+func (this *DescribeActivityExecutionRequest) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
 	}
 
-	var that1 *PollActivityExecutionRequest
+	var that1 *DescribeActivityExecutionRequest
 	switch t := that.(type) {
-	case *PollActivityExecutionRequest:
+	case *DescribeActivityExecutionRequest:
 		that1 = t
-	case PollActivityExecutionRequest:
+	case DescribeActivityExecutionRequest:
 		that1 = &t
 	default:
 		return false
@@ -116,35 +116,109 @@ func (this *PollActivityExecutionRequest) Equal(that interface{}) bool {
 	return proto.Equal(this, that1)
 }
 
-// Marshal an object of type PollActivityExecutionResponse to the protobuf v3 wire format
-func (val *PollActivityExecutionResponse) Marshal() ([]byte, error) {
+// Marshal an object of type DescribeActivityExecutionResponse to the protobuf v3 wire format
+func (val *DescribeActivityExecutionResponse) Marshal() ([]byte, error) {
 	return proto.Marshal(val)
 }
 
-// Unmarshal an object of type PollActivityExecutionResponse from the protobuf v3 wire format
-func (val *PollActivityExecutionResponse) Unmarshal(buf []byte) error {
+// Unmarshal an object of type DescribeActivityExecutionResponse from the protobuf v3 wire format
+func (val *DescribeActivityExecutionResponse) Unmarshal(buf []byte) error {
 	return proto.Unmarshal(buf, val)
 }
 
 // Size returns the size of the object, in bytes, once serialized
-func (val *PollActivityExecutionResponse) Size() int {
+func (val *DescribeActivityExecutionResponse) Size() int {
 	return proto.Size(val)
 }
 
-// Equal returns whether two PollActivityExecutionResponse values are equivalent by recursively
+// Equal returns whether two DescribeActivityExecutionResponse values are equivalent by recursively
 // comparing the message's fields.
 // For more information see the documentation for
 // https://pkg.go.dev/google.golang.org/protobuf/proto#Equal
-func (this *PollActivityExecutionResponse) Equal(that interface{}) bool {
+func (this *DescribeActivityExecutionResponse) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
 	}
 
-	var that1 *PollActivityExecutionResponse
+	var that1 *DescribeActivityExecutionResponse
 	switch t := that.(type) {
-	case *PollActivityExecutionResponse:
+	case *DescribeActivityExecutionResponse:
 		that1 = t
-	case PollActivityExecutionResponse:
+	case DescribeActivityExecutionResponse:
+		that1 = &t
+	default:
+		return false
+	}
+
+	return proto.Equal(this, that1)
+}
+
+// Marshal an object of type GetActivityExecutionOutcomeRequest to the protobuf v3 wire format
+func (val *GetActivityExecutionOutcomeRequest) Marshal() ([]byte, error) {
+	return proto.Marshal(val)
+}
+
+// Unmarshal an object of type GetActivityExecutionOutcomeRequest from the protobuf v3 wire format
+func (val *GetActivityExecutionOutcomeRequest) Unmarshal(buf []byte) error {
+	return proto.Unmarshal(buf, val)
+}
+
+// Size returns the size of the object, in bytes, once serialized
+func (val *GetActivityExecutionOutcomeRequest) Size() int {
+	return proto.Size(val)
+}
+
+// Equal returns whether two GetActivityExecutionOutcomeRequest values are equivalent by recursively
+// comparing the message's fields.
+// For more information see the documentation for
+// https://pkg.go.dev/google.golang.org/protobuf/proto#Equal
+func (this *GetActivityExecutionOutcomeRequest) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	var that1 *GetActivityExecutionOutcomeRequest
+	switch t := that.(type) {
+	case *GetActivityExecutionOutcomeRequest:
+		that1 = t
+	case GetActivityExecutionOutcomeRequest:
+		that1 = &t
+	default:
+		return false
+	}
+
+	return proto.Equal(this, that1)
+}
+
+// Marshal an object of type GetActivityExecutionOutcomeResponse to the protobuf v3 wire format
+func (val *GetActivityExecutionOutcomeResponse) Marshal() ([]byte, error) {
+	return proto.Marshal(val)
+}
+
+// Unmarshal an object of type GetActivityExecutionOutcomeResponse from the protobuf v3 wire format
+func (val *GetActivityExecutionOutcomeResponse) Unmarshal(buf []byte) error {
+	return proto.Unmarshal(buf, val)
+}
+
+// Size returns the size of the object, in bytes, once serialized
+func (val *GetActivityExecutionOutcomeResponse) Size() int {
+	return proto.Size(val)
+}
+
+// Equal returns whether two GetActivityExecutionOutcomeResponse values are equivalent by recursively
+// comparing the message's fields.
+// For more information see the documentation for
+// https://pkg.go.dev/google.golang.org/protobuf/proto#Equal
+func (this *GetActivityExecutionOutcomeResponse) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	var that1 *GetActivityExecutionOutcomeResponse
+	switch t := that.(type) {
+	case *GetActivityExecutionOutcomeResponse:
+		that1 = t
+	case GetActivityExecutionOutcomeResponse:
 		that1 = &t
 	default:
 		return false
diff --git a/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go b/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go
index 766bd220ae..3ea1ebf01a 100644
--- a/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go
+++ b/chasm/lib/activity/gen/activitypb/v1/request_response.pb.go
@@ -119,28 +119,28 @@ func (x *StartActivityExecutionResponse) GetFrontendResponse() *v1.StartActivity
 	return nil
 }
 
-type PollActivityExecutionRequest struct {
-	state           protoimpl.MessageState           `protogen:"open.v1"`
-	NamespaceId     string                           `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"`
-	FrontendRequest *v1.PollActivityExecutionRequest `protobuf:"bytes,2,opt,name=frontend_request,json=frontendRequest,proto3" json:"frontend_request,omitempty"`
+type DescribeActivityExecutionRequest struct {
+	state           protoimpl.MessageState               `protogen:"open.v1"`
+	NamespaceId     string                               `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"`
+	FrontendRequest *v1.DescribeActivityExecutionRequest `protobuf:"bytes,2,opt,name=frontend_request,json=frontendRequest,proto3" json:"frontend_request,omitempty"`
 	unknownFields   protoimpl.UnknownFields
 	sizeCache       protoimpl.SizeCache
 }
 
-func (x *PollActivityExecutionRequest) Reset() {
-	*x = PollActivityExecutionRequest{}
+func (x *DescribeActivityExecutionRequest) Reset() {
+	*x = DescribeActivityExecutionRequest{}
 	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[2]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *PollActivityExecutionRequest) String() string {
+func (x *DescribeActivityExecutionRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PollActivityExecutionRequest) ProtoMessage() {}
+func (*DescribeActivityExecutionRequest) ProtoMessage() {}
 
-func (x *PollActivityExecutionRequest) ProtoReflect() protoreflect.Message {
+func (x *DescribeActivityExecutionRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[2]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -152,46 +152,46 @@ func (x *PollActivityExecutionRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use PollActivityExecutionRequest.ProtoReflect.Descriptor instead.
-func (*PollActivityExecutionRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use DescribeActivityExecutionRequest.ProtoReflect.Descriptor instead.
+func (*DescribeActivityExecutionRequest) Descriptor() ([]byte, []int) {
 	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{2}
 }
 
-func (x *PollActivityExecutionRequest) GetNamespaceId() string {
+func (x *DescribeActivityExecutionRequest) GetNamespaceId() string {
 	if x != nil {
 		return x.NamespaceId
 	}
 	return ""
 }
 
-func (x *PollActivityExecutionRequest) GetFrontendRequest() *v1.PollActivityExecutionRequest {
+func (x *DescribeActivityExecutionRequest) GetFrontendRequest() *v1.DescribeActivityExecutionRequest {
 	if x != nil {
 		return x.FrontendRequest
 	}
 	return nil
 }
 
-type PollActivityExecutionResponse struct {
-	state            protoimpl.MessageState            `protogen:"open.v1"`
-	FrontendResponse *v1.PollActivityExecutionResponse `protobuf:"bytes,1,opt,name=frontend_response,json=frontendResponse,proto3" json:"frontend_response,omitempty"`
+type DescribeActivityExecutionResponse struct {
+	state            protoimpl.MessageState                `protogen:"open.v1"`
+	FrontendResponse *v1.DescribeActivityExecutionResponse `protobuf:"bytes,1,opt,name=frontend_response,json=frontendResponse,proto3" json:"frontend_response,omitempty"`
 	unknownFields    protoimpl.UnknownFields
 	sizeCache        protoimpl.SizeCache
 }
 
-func (x *PollActivityExecutionResponse) Reset() {
-	*x = PollActivityExecutionResponse{}
+func (x *DescribeActivityExecutionResponse) Reset() {
+	*x = DescribeActivityExecutionResponse{}
 	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[3]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *PollActivityExecutionResponse) String() string {
+func (x *DescribeActivityExecutionResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*PollActivityExecutionResponse) ProtoMessage() {}
+func (*DescribeActivityExecutionResponse) ProtoMessage() {}
 
-func (x *PollActivityExecutionResponse) ProtoReflect() protoreflect.Message {
+func (x *DescribeActivityExecutionResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[3]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -203,12 +203,108 @@ func (x *PollActivityExecutionResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use PollActivityExecutionResponse.ProtoReflect.Descriptor instead.
-func (*PollActivityExecutionResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use DescribeActivityExecutionResponse.ProtoReflect.Descriptor instead.
+func (*DescribeActivityExecutionResponse) Descriptor() ([]byte, []int) {
 	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{3}
 }
 
-func (x *PollActivityExecutionResponse) GetFrontendResponse() *v1.PollActivityExecutionResponse {
+func (x *DescribeActivityExecutionResponse) GetFrontendResponse() *v1.DescribeActivityExecutionResponse {
+	if x != nil {
+		return x.FrontendResponse
+	}
+	return nil
+}
+
+type GetActivityExecutionOutcomeRequest struct {
+	state           protoimpl.MessageState                 `protogen:"open.v1"`
+	NamespaceId     string                                 `protobuf:"bytes,1,opt,name=namespace_id,json=namespaceId,proto3" json:"namespace_id,omitempty"`
+	FrontendRequest *v1.GetActivityExecutionOutcomeRequest `protobuf:"bytes,2,opt,name=frontend_request,json=frontendRequest,proto3" json:"frontend_request,omitempty"`
+	unknownFields   protoimpl.UnknownFields
+	sizeCache       protoimpl.SizeCache
+}
+
+func (x *GetActivityExecutionOutcomeRequest) Reset() {
+	*x = GetActivityExecutionOutcomeRequest{}
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[4]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetActivityExecutionOutcomeRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetActivityExecutionOutcomeRequest) ProtoMessage() {}
+
+func (x *GetActivityExecutionOutcomeRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[4]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetActivityExecutionOutcomeRequest.ProtoReflect.Descriptor instead.
+func (*GetActivityExecutionOutcomeRequest) Descriptor() ([]byte, []int) {
+	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{4}
+}
+
+func (x *GetActivityExecutionOutcomeRequest) GetNamespaceId() string {
+	if x != nil {
+		return x.NamespaceId
+	}
+	return ""
+}
+
+func (x *GetActivityExecutionOutcomeRequest) GetFrontendRequest() *v1.GetActivityExecutionOutcomeRequest {
+	if x != nil {
+		return x.FrontendRequest
+	}
+	return nil
+}
+
+type GetActivityExecutionOutcomeResponse struct {
+	state            protoimpl.MessageState                  `protogen:"open.v1"`
+	FrontendResponse *v1.GetActivityExecutionOutcomeResponse `protobuf:"bytes,1,opt,name=frontend_response,json=frontendResponse,proto3" json:"frontend_response,omitempty"`
+	unknownFields    protoimpl.UnknownFields
+	sizeCache        protoimpl.SizeCache
+}
+
+func (x *GetActivityExecutionOutcomeResponse) Reset() {
+	*x = GetActivityExecutionOutcomeResponse{}
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[5]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *GetActivityExecutionOutcomeResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*GetActivityExecutionOutcomeResponse) ProtoMessage() {}
+
+func (x *GetActivityExecutionOutcomeResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[5]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use GetActivityExecutionOutcomeResponse.ProtoReflect.Descriptor instead.
+func (*GetActivityExecutionOutcomeResponse) Descriptor() ([]byte, []int) {
+	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{5}
+}
+
+func (x *GetActivityExecutionOutcomeResponse) GetFrontendResponse() *v1.GetActivityExecutionOutcomeResponse {
 	if x != nil {
 		return x.FrontendResponse
 	}
@@ -225,7 +321,7 @@ type TerminateActivityExecutionRequest struct {
 
 func (x *TerminateActivityExecutionRequest) Reset() {
 	*x = TerminateActivityExecutionRequest{}
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[4]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[6]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -237,7 +333,7 @@ func (x *TerminateActivityExecutionRequest) String() string {
 func (*TerminateActivityExecutionRequest) ProtoMessage() {}
 
 func (x *TerminateActivityExecutionRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[4]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[6]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -250,7 +346,7 @@ func (x *TerminateActivityExecutionRequest) ProtoReflect() protoreflect.Message
 
 // Deprecated: Use TerminateActivityExecutionRequest.ProtoReflect.Descriptor instead.
 func (*TerminateActivityExecutionRequest) Descriptor() ([]byte, []int) {
-	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{4}
+	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{6}
 }
 
 func (x *TerminateActivityExecutionRequest) GetNamespaceId() string {
@@ -275,7 +371,7 @@ type TerminateActivityExecutionResponse struct {
 
 func (x *TerminateActivityExecutionResponse) Reset() {
 	*x = TerminateActivityExecutionResponse{}
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[5]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[7]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -287,7 +383,7 @@ func (x *TerminateActivityExecutionResponse) String() string {
 func (*TerminateActivityExecutionResponse) ProtoMessage() {}
 
 func (x *TerminateActivityExecutionResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[5]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[7]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -300,7 +396,7 @@ func (x *TerminateActivityExecutionResponse) ProtoReflect() protoreflect.Message
 
 // Deprecated: Use TerminateActivityExecutionResponse.ProtoReflect.Descriptor instead.
 func (*TerminateActivityExecutionResponse) Descriptor() ([]byte, []int) {
-	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{5}
+	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{7}
 }
 
 type RequestCancelActivityExecutionRequest struct {
@@ -313,7 +409,7 @@ type RequestCancelActivityExecutionRequest struct {
 
 func (x *RequestCancelActivityExecutionRequest) Reset() {
 	*x = RequestCancelActivityExecutionRequest{}
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[6]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[8]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -325,7 +421,7 @@ func (x *RequestCancelActivityExecutionRequest) String() string {
 func (*RequestCancelActivityExecutionRequest) ProtoMessage() {}
 
 func (x *RequestCancelActivityExecutionRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[6]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[8]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -338,7 +434,7 @@ func (x *RequestCancelActivityExecutionRequest) ProtoReflect() protoreflect.Mess
 
 // Deprecated: Use RequestCancelActivityExecutionRequest.ProtoReflect.Descriptor instead.
 func (*RequestCancelActivityExecutionRequest) Descriptor() ([]byte, []int) {
-	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{6}
+	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{8}
 }
 
 func (x *RequestCancelActivityExecutionRequest) GetNamespaceId() string {
@@ -363,7 +459,7 @@ type RequestCancelActivityExecutionResponse struct {
 
 func (x *RequestCancelActivityExecutionResponse) Reset() {
 	*x = RequestCancelActivityExecutionResponse{}
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[7]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[9]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
@@ -375,7 +471,7 @@ func (x *RequestCancelActivityExecutionResponse) String() string {
 func (*RequestCancelActivityExecutionResponse) ProtoMessage() {}
 
 func (x *RequestCancelActivityExecutionResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[7]
+	mi := &file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes[9]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -388,7 +484,7 @@ func (x *RequestCancelActivityExecutionResponse) ProtoReflect() protoreflect.Mes
 
 // Deprecated: Use RequestCancelActivityExecutionResponse.ProtoReflect.Descriptor instead.
 func (*RequestCancelActivityExecutionResponse) Descriptor() ([]byte, []int) {
-	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{7}
+	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescGZIP(), []int{9}
 }
 
 var File_temporal_server_chasm_lib_activity_proto_v1_request_response_proto protoreflect.FileDescriptor
@@ -400,12 +496,17 @@ const file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_ra
 	"\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12i\n" +
 	"\x10frontend_request\x18\x02 \x01(\v2>.temporal.api.workflowservice.v1.StartActivityExecutionRequestR\x0ffrontendRequest\"\x8e\x01\n" +
 	"\x1eStartActivityExecutionResponse\x12l\n" +
-	"\x11frontend_response\x18\x01 \x01(\v2?.temporal.api.workflowservice.v1.StartActivityExecutionResponseR\x10frontendResponse\"\xab\x01\n" +
-	"\x1cPollActivityExecutionRequest\x12!\n" +
-	"\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12h\n" +
-	"\x10frontend_request\x18\x02 \x01(\v2=.temporal.api.workflowservice.v1.PollActivityExecutionRequestR\x0ffrontendRequest\"\x8c\x01\n" +
-	"\x1dPollActivityExecutionResponse\x12k\n" +
-	"\x11frontend_response\x18\x01 \x01(\v2>.temporal.api.workflowservice.v1.PollActivityExecutionResponseR\x10frontendResponse\"\xb5\x01\n" +
+	"\x11frontend_response\x18\x01 \x01(\v2?.temporal.api.workflowservice.v1.StartActivityExecutionResponseR\x10frontendResponse\"\xb3\x01\n" +
+	" DescribeActivityExecutionRequest\x12!\n" +
+	"\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12l\n" +
+	"\x10frontend_request\x18\x02 \x01(\v2A.temporal.api.workflowservice.v1.DescribeActivityExecutionRequestR\x0ffrontendRequest\"\x94\x01\n" +
+	"!DescribeActivityExecutionResponse\x12o\n" +
+	"\x11frontend_response\x18\x01 \x01(\v2B.temporal.api.workflowservice.v1.DescribeActivityExecutionResponseR\x10frontendResponse\"\xb7\x01\n" +
+	"\"GetActivityExecutionOutcomeRequest\x12!\n" +
+	"\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12n\n" +
+	"\x10frontend_request\x18\x02 \x01(\v2C.temporal.api.workflowservice.v1.GetActivityExecutionOutcomeRequestR\x0ffrontendRequest\"\x98\x01\n" +
+	"#GetActivityExecutionOutcomeResponse\x12q\n" +
+	"\x11frontend_response\x18\x01 \x01(\v2D.temporal.api.workflowservice.v1.GetActivityExecutionOutcomeResponseR\x10frontendResponse\"\xb5\x01\n" +
 	"!TerminateActivityExecutionRequest\x12!\n" +
 	"\fnamespace_id\x18\x01 \x01(\tR\vnamespaceId\x12m\n" +
 	"\x10frontend_request\x18\x02 \x01(\v2B.temporal.api.workflowservice.v1.TerminateActivityExecutionRequestR\x0ffrontendRequest\"$\n" +
@@ -427,35 +528,41 @@ func file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_raw
 	return file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDescData
 }
 
-var file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
+var file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_msgTypes = make([]protoimpl.MessageInfo, 10)
 var file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_goTypes = []any{
 	(*StartActivityExecutionRequest)(nil),            // 0: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest
 	(*StartActivityExecutionResponse)(nil),           // 1: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse
-	(*PollActivityExecutionRequest)(nil),             // 2: temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionRequest
-	(*PollActivityExecutionResponse)(nil),            // 3: temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionResponse
-	(*TerminateActivityExecutionRequest)(nil),        // 4: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest
-	(*TerminateActivityExecutionResponse)(nil),       // 5: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse
-	(*RequestCancelActivityExecutionRequest)(nil),    // 6: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest
-	(*RequestCancelActivityExecutionResponse)(nil),   // 7: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse
-	(*v1.StartActivityExecutionRequest)(nil),         // 8: temporal.api.workflowservice.v1.StartActivityExecutionRequest
-	(*v1.StartActivityExecutionResponse)(nil),        // 9: temporal.api.workflowservice.v1.StartActivityExecutionResponse
-	(*v1.PollActivityExecutionRequest)(nil),          // 10: temporal.api.workflowservice.v1.PollActivityExecutionRequest
-	(*v1.PollActivityExecutionResponse)(nil),         // 11: temporal.api.workflowservice.v1.PollActivityExecutionResponse
-	(*v1.TerminateActivityExecutionRequest)(nil),     // 12: temporal.api.workflowservice.v1.TerminateActivityExecutionRequest
-	(*v1.RequestCancelActivityExecutionRequest)(nil), // 13: temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest
+	(*DescribeActivityExecutionRequest)(nil),         // 2: temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionRequest
+	(*DescribeActivityExecutionResponse)(nil),        // 3: temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionResponse
+	(*GetActivityExecutionOutcomeRequest)(nil),       // 4: temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeRequest
+	(*GetActivityExecutionOutcomeResponse)(nil),      // 5: temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeResponse
+	(*TerminateActivityExecutionRequest)(nil),        // 6: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest
+	(*TerminateActivityExecutionResponse)(nil),       // 7: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse
+	(*RequestCancelActivityExecutionRequest)(nil),    // 8: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest
+	(*RequestCancelActivityExecutionResponse)(nil),   // 9: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse
+	(*v1.StartActivityExecutionRequest)(nil),         // 10: temporal.api.workflowservice.v1.StartActivityExecutionRequest
+	(*v1.StartActivityExecutionResponse)(nil),        // 11: temporal.api.workflowservice.v1.StartActivityExecutionResponse
+	(*v1.DescribeActivityExecutionRequest)(nil),      // 12: temporal.api.workflowservice.v1.DescribeActivityExecutionRequest
+	(*v1.DescribeActivityExecutionResponse)(nil),     // 13: temporal.api.workflowservice.v1.DescribeActivityExecutionResponse
+	(*v1.GetActivityExecutionOutcomeRequest)(nil),    // 14: temporal.api.workflowservice.v1.GetActivityExecutionOutcomeRequest
+	(*v1.GetActivityExecutionOutcomeResponse)(nil),   // 15: temporal.api.workflowservice.v1.GetActivityExecutionOutcomeResponse
+	(*v1.TerminateActivityExecutionRequest)(nil),     // 16: temporal.api.workflowservice.v1.TerminateActivityExecutionRequest
+	(*v1.RequestCancelActivityExecutionRequest)(nil), // 17: temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest
 }
 var file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_depIdxs = []int32{
-	8,  // 0: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.StartActivityExecutionRequest
-	9,  // 1: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse.frontend_response:type_name -> temporal.api.workflowservice.v1.StartActivityExecutionResponse
-	10, // 2: temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.PollActivityExecutionRequest
-	11, // 3: temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionResponse.frontend_response:type_name -> temporal.api.workflowservice.v1.PollActivityExecutionResponse
-	12, // 4: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.TerminateActivityExecutionRequest
-	13, // 5: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest
-	6,  // [6:6] is the sub-list for method output_type
-	6,  // [6:6] is the sub-list for method input_type
-	6,  // [6:6] is the sub-list for extension type_name
-	6,  // [6:6] is the sub-list for extension extendee
-	0,  // [0:6] is the sub-list for field type_name
+	10, // 0: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.StartActivityExecutionRequest
+	11, // 1: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse.frontend_response:type_name -> temporal.api.workflowservice.v1.StartActivityExecutionResponse
+	12, // 2: temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.DescribeActivityExecutionRequest
+	13, // 3: temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionResponse.frontend_response:type_name -> temporal.api.workflowservice.v1.DescribeActivityExecutionResponse
+	14, // 4: temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.GetActivityExecutionOutcomeRequest
+	15, // 5: temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeResponse.frontend_response:type_name -> temporal.api.workflowservice.v1.GetActivityExecutionOutcomeResponse
+	16, // 6: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.TerminateActivityExecutionRequest
+	17, // 7: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest.frontend_request:type_name -> temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest
+	8,  // [8:8] is the sub-list for method output_type
+	8,  // [8:8] is the sub-list for method input_type
+	8,  // [8:8] is the sub-list for extension type_name
+	8,  // [8:8] is the sub-list for extension extendee
+	0,  // [0:8] is the sub-list for field type_name
 }
 
 func init() { file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_init() }
@@ -469,7 +576,7 @@ func file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_ini
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: unsafe.Slice(unsafe.StringData(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc), len(file_temporal_server_chasm_lib_activity_proto_v1_request_response_proto_rawDesc)),
 			NumEnums:      0,
-			NumMessages:   8,
+			NumMessages:   10,
 			NumExtensions: 0,
 			NumServices:   0,
 		},
diff --git a/chasm/lib/activity/gen/activitypb/v1/service.pb.go b/chasm/lib/activity/gen/activitypb/v1/service.pb.go
index 012d6c1690..be24157ac7 100644
--- a/chasm/lib/activity/gen/activitypb/v1/service.pb.go
+++ b/chasm/lib/activity/gen/activitypb/v1/service.pb.go
@@ -26,34 +26,39 @@ var File_temporal_server_chasm_lib_activity_proto_v1_service_proto protoreflect.
 
 const file_temporal_server_chasm_lib_activity_proto_v1_service_proto_rawDesc = "" +
 	"\n" +
-	"9temporal/server/chasm/lib/activity/proto/v1/service.proto\x12+temporal.server.chasm.lib.activity.proto.v1\x1aBtemporal/server/chasm/lib/activity/proto/v1/request_response.proto\x1a.temporal/server/api/routing/v1/extension.proto2\x92\a\n" +
+	"9temporal/server/chasm/lib/activity/proto/v1/service.proto\x12+temporal.server.chasm.lib.activity.proto.v1\x1aBtemporal/server/chasm/lib/activity/proto/v1/request_response.proto\x1a.temporal/server/api/routing/v1/extension.proto2\x85\t\n" +
 	"\x0fActivityService\x12\xd5\x01\n" +
-	"\x16StartActivityExecution\x12J.temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest\x1aK.temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_id\x12\xd2\x01\n" +
-	"\x15PollActivityExecution\x12I.temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionRequest\x1aJ.temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_id\x12\xe1\x01\n" +
+	"\x16StartActivityExecution\x12J.temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest\x1aK.temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_id\x12\xde\x01\n" +
+	"\x19DescribeActivityExecution\x12M.temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionRequest\x1aN.temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_id\x12\xe4\x01\n" +
+	"\x1bGetActivityExecutionOutcome\x12O.temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeRequest\x1aP.temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_id\x12\xe1\x01\n" +
 	"\x1aTerminateActivityExecution\x12N.temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest\x1aO.temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_id\x12\xed\x01\n" +
 	"\x1eRequestCancelActivityExecution\x12R.temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest\x1aS.temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse\"\"\x92\xc4\x03\x1e\x1a\x1cfrontend_request.activity_idBDZBgo.temporal.io/server/chasm/lib/activity/gen/activitypb;activitypbb\x06proto3"
 
 var file_temporal_server_chasm_lib_activity_proto_v1_service_proto_goTypes = []any{
 	(*StartActivityExecutionRequest)(nil),          // 0: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest
-	(*PollActivityExecutionRequest)(nil),           // 1: temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionRequest
-	(*TerminateActivityExecutionRequest)(nil),      // 2: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest
-	(*RequestCancelActivityExecutionRequest)(nil),  // 3: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest
-	(*StartActivityExecutionResponse)(nil),         // 4: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse
-	(*PollActivityExecutionResponse)(nil),          // 5: temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionResponse
-	(*TerminateActivityExecutionResponse)(nil),     // 6: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse
-	(*RequestCancelActivityExecutionResponse)(nil), // 7: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse
+	(*DescribeActivityExecutionRequest)(nil),       // 1: temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionRequest
+	(*GetActivityExecutionOutcomeRequest)(nil),     // 2: temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeRequest
+	(*TerminateActivityExecutionRequest)(nil),      // 3: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest
+	(*RequestCancelActivityExecutionRequest)(nil),  // 4: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest
+	(*StartActivityExecutionResponse)(nil),         // 5: temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse
+	(*DescribeActivityExecutionResponse)(nil),      // 6: temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionResponse
+	(*GetActivityExecutionOutcomeResponse)(nil),    // 7: temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeResponse
+	(*TerminateActivityExecutionResponse)(nil),     // 8: temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse
+	(*RequestCancelActivityExecutionResponse)(nil), // 9: temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse
 }
 var file_temporal_server_chasm_lib_activity_proto_v1_service_proto_depIdxs = []int32{
 	0, // 0: temporal.server.chasm.lib.activity.proto.v1.ActivityService.StartActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionRequest
-	1, // 1: temporal.server.chasm.lib.activity.proto.v1.ActivityService.PollActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionRequest
-	2, // 2: temporal.server.chasm.lib.activity.proto.v1.ActivityService.TerminateActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest
-	3, // 3: temporal.server.chasm.lib.activity.proto.v1.ActivityService.RequestCancelActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest
-	4, // 4: temporal.server.chasm.lib.activity.proto.v1.ActivityService.StartActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse
-	5, // 5: temporal.server.chasm.lib.activity.proto.v1.ActivityService.PollActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.PollActivityExecutionResponse
-	6, // 6: temporal.server.chasm.lib.activity.proto.v1.ActivityService.TerminateActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse
-	7, // 7: temporal.server.chasm.lib.activity.proto.v1.ActivityService.RequestCancelActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse
-	4, // [4:8] is the sub-list for method output_type
-	0, // [0:4] is the sub-list for method input_type
+	1, // 1: temporal.server.chasm.lib.activity.proto.v1.ActivityService.DescribeActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionRequest
+	2, // 2: temporal.server.chasm.lib.activity.proto.v1.ActivityService.GetActivityExecutionOutcome:input_type -> temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeRequest
+	3, // 3: temporal.server.chasm.lib.activity.proto.v1.ActivityService.TerminateActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionRequest
+	4, // 4: temporal.server.chasm.lib.activity.proto.v1.ActivityService.RequestCancelActivityExecution:input_type -> temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionRequest
+	5, // 5: temporal.server.chasm.lib.activity.proto.v1.ActivityService.StartActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.StartActivityExecutionResponse
+	6, // 6: temporal.server.chasm.lib.activity.proto.v1.ActivityService.DescribeActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.DescribeActivityExecutionResponse
+	7, // 7: temporal.server.chasm.lib.activity.proto.v1.ActivityService.GetActivityExecutionOutcome:output_type -> temporal.server.chasm.lib.activity.proto.v1.GetActivityExecutionOutcomeResponse
+	8, // 8: temporal.server.chasm.lib.activity.proto.v1.ActivityService.TerminateActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.TerminateActivityExecutionResponse
+	9, // 9: temporal.server.chasm.lib.activity.proto.v1.ActivityService.RequestCancelActivityExecution:output_type -> temporal.server.chasm.lib.activity.proto.v1.RequestCancelActivityExecutionResponse
+	5, // [5:10] is the sub-list for method output_type
+	0, // [0:5] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name
 	0, // [0:0] is the sub-list for extension extendee
 	0, // [0:0] is the sub-list for field type_name
diff --git a/chasm/lib/activity/gen/activitypb/v1/service_client.pb.go b/chasm/lib/activity/gen/activitypb/v1/service_client.pb.go
index 50d836df5f..4fa46eff6e 100644
--- a/chasm/lib/activity/gen/activitypb/v1/service_client.pb.go
+++ b/chasm/lib/activity/gen/activitypb/v1/service_client.pb.go
@@ -101,18 +101,18 @@ func (c *ActivityServiceLayeredClient) StartActivityExecution(
 	}
 	return backoff.ThrottleRetryContextWithReturn(ctx, call, c.retryPolicy, common.IsServiceClientTransientError)
 }
-func (c *ActivityServiceLayeredClient) callPollActivityExecutionNoRetry(
+func (c *ActivityServiceLayeredClient) callDescribeActivityExecutionNoRetry(
 	ctx context.Context,
-	request *PollActivityExecutionRequest,
+	request *DescribeActivityExecutionRequest,
 	opts ...grpc.CallOption,
-) (*PollActivityExecutionResponse, error) {
-	var response *PollActivityExecutionResponse
+) (*DescribeActivityExecutionResponse, error) {
+	var response *DescribeActivityExecutionResponse
 	var err error
 	startTime := time.Now().UTC()
 	// the caller is a namespace, hence the tag below.
 	caller := headers.GetCallerInfo(ctx).CallerName
 	metricsHandler := c.metricsHandler.WithTags(
-		metrics.OperationTag("ActivityService.PollActivityExecution"),
+		metrics.OperationTag("ActivityService.DescribeActivityExecution"),
 		metrics.NamespaceTag(caller),
 		metrics.ServiceRoleTag(metrics.HistoryRoleTagValue),
 	)
@@ -128,19 +128,62 @@ func (c *ActivityServiceLayeredClient) callPollActivityExecutionNoRetry(
 		var err error
 		ctx, cancel := context.WithTimeout(ctx, history.DefaultTimeout)
 		defer cancel()
-		response, err = client.PollActivityExecution(ctx, request, opts...)
+		response, err = client.DescribeActivityExecution(ctx, request, opts...)
 		return err
 	}
 	err = c.redirector.Execute(ctx, shardID, op)
 	return response, err
 }
-func (c *ActivityServiceLayeredClient) PollActivityExecution(
+func (c *ActivityServiceLayeredClient) DescribeActivityExecution(
 	ctx context.Context,
-	request *PollActivityExecutionRequest,
+	request *DescribeActivityExecutionRequest,
 	opts ...grpc.CallOption,
-) (*PollActivityExecutionResponse, error) {
-	call := func(ctx context.Context) (*PollActivityExecutionResponse, error) {
-		return c.callPollActivityExecutionNoRetry(ctx, request, opts...)
+) (*DescribeActivityExecutionResponse, error) {
+	call := func(ctx context.Context) (*DescribeActivityExecutionResponse, error) {
+		return c.callDescribeActivityExecutionNoRetry(ctx, request, opts...)
+	}
+	return backoff.ThrottleRetryContextWithReturn(ctx, call, c.retryPolicy, common.IsServiceClientTransientError)
+}
+func (c *ActivityServiceLayeredClient) callGetActivityExecutionOutcomeNoRetry(
+	ctx context.Context,
+	request *GetActivityExecutionOutcomeRequest,
+	opts ...grpc.CallOption,
+) (*GetActivityExecutionOutcomeResponse, error) {
+	var response *GetActivityExecutionOutcomeResponse
+	var err error
+	startTime := time.Now().UTC()
+	// the caller is a namespace, hence the tag below.
+	caller := headers.GetCallerInfo(ctx).CallerName
+	metricsHandler := c.metricsHandler.WithTags(
+		metrics.OperationTag("ActivityService.GetActivityExecutionOutcome"),
+		metrics.NamespaceTag(caller),
+		metrics.ServiceRoleTag(metrics.HistoryRoleTagValue),
+	)
+	metrics.ClientRequests.With(metricsHandler).Record(1)
+	defer func() {
+		if err != nil {
+			metrics.ClientFailures.With(metricsHandler).Record(1, metrics.ServiceErrorTypeTag(err))
+		}
+		metrics.ClientLatency.With(metricsHandler).Record(time.Since(startTime))
+	}()
+	shardID := common.WorkflowIDToHistoryShard(request.GetNamespaceId(), request.GetFrontendRequest().GetActivityId(), c.numShards)
+	op := func(ctx context.Context, client ActivityServiceClient) error {
+		var err error
+		ctx, cancel := context.WithTimeout(ctx, history.DefaultTimeout)
+		defer cancel()
+		response, err = client.GetActivityExecutionOutcome(ctx, request, opts...)
+		return err
+	}
+	err = c.redirector.Execute(ctx, shardID, op)
+	return response, err
+}
+func (c *ActivityServiceLayeredClient) GetActivityExecutionOutcome(
+	ctx context.Context,
+	request *GetActivityExecutionOutcomeRequest,
+	opts ...grpc.CallOption,
+) (*GetActivityExecutionOutcomeResponse, error) {
+	call := func(ctx context.Context) (*GetActivityExecutionOutcomeResponse, error) {
+		return c.callGetActivityExecutionOutcomeNoRetry(ctx, request, opts...)
 	}
 	return backoff.ThrottleRetryContextWithReturn(ctx, call, c.retryPolicy, common.IsServiceClientTransientError)
 }
diff --git a/chasm/lib/activity/gen/activitypb/v1/service_grpc.pb.go b/chasm/lib/activity/gen/activitypb/v1/service_grpc.pb.go
index 0021803b49..7c1cc2c4e2 100644
--- a/chasm/lib/activity/gen/activitypb/v1/service_grpc.pb.go
+++ b/chasm/lib/activity/gen/activitypb/v1/service_grpc.pb.go
@@ -21,7 +21,8 @@ const _ = grpc.SupportPackageIsVersion7
 
 const (
 	ActivityService_StartActivityExecution_FullMethodName         = "/temporal.server.chasm.lib.activity.proto.v1.ActivityService/StartActivityExecution"
-	ActivityService_PollActivityExecution_FullMethodName          = "/temporal.server.chasm.lib.activity.proto.v1.ActivityService/PollActivityExecution"
+	ActivityService_DescribeActivityExecution_FullMethodName      = "/temporal.server.chasm.lib.activity.proto.v1.ActivityService/DescribeActivityExecution"
+	ActivityService_GetActivityExecutionOutcome_FullMethodName    = "/temporal.server.chasm.lib.activity.proto.v1.ActivityService/GetActivityExecutionOutcome"
 	ActivityService_TerminateActivityExecution_FullMethodName     = "/temporal.server.chasm.lib.activity.proto.v1.ActivityService/TerminateActivityExecution"
 	ActivityService_RequestCancelActivityExecution_FullMethodName = "/temporal.server.chasm.lib.activity.proto.v1.ActivityService/RequestCancelActivityExecution"
 )
@@ -31,7 +32,8 @@ const (
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type ActivityServiceClient interface {
 	StartActivityExecution(ctx context.Context, in *StartActivityExecutionRequest, opts ...grpc.CallOption) (*StartActivityExecutionResponse, error)
-	PollActivityExecution(ctx context.Context, in *PollActivityExecutionRequest, opts ...grpc.CallOption) (*PollActivityExecutionResponse, error)
+	DescribeActivityExecution(ctx context.Context, in *DescribeActivityExecutionRequest, opts ...grpc.CallOption) (*DescribeActivityExecutionResponse, error)
+	GetActivityExecutionOutcome(ctx context.Context, in *GetActivityExecutionOutcomeRequest, opts ...grpc.CallOption) (*GetActivityExecutionOutcomeResponse, error)
 	TerminateActivityExecution(ctx context.Context, in *TerminateActivityExecutionRequest, opts ...grpc.CallOption) (*TerminateActivityExecutionResponse, error)
 	RequestCancelActivityExecution(ctx context.Context, in *RequestCancelActivityExecutionRequest, opts ...grpc.CallOption) (*RequestCancelActivityExecutionResponse, error)
 }
@@ -53,9 +55,18 @@ func (c *activityServiceClient) StartActivityExecution(ctx context.Context, in *
 	return out, nil
 }
 
-func (c *activityServiceClient) PollActivityExecution(ctx context.Context, in *PollActivityExecutionRequest, opts ...grpc.CallOption) (*PollActivityExecutionResponse, error) {
-	out := new(PollActivityExecutionResponse)
-	err := c.cc.Invoke(ctx, ActivityService_PollActivityExecution_FullMethodName, in, out, opts...)
+func (c *activityServiceClient) DescribeActivityExecution(ctx context.Context, in *DescribeActivityExecutionRequest, opts ...grpc.CallOption) (*DescribeActivityExecutionResponse, error) {
+	out := new(DescribeActivityExecutionResponse)
+	err := c.cc.Invoke(ctx, ActivityService_DescribeActivityExecution_FullMethodName, in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *activityServiceClient) GetActivityExecutionOutcome(ctx context.Context, in *GetActivityExecutionOutcomeRequest, opts ...grpc.CallOption) (*GetActivityExecutionOutcomeResponse, error) {
+	out := new(GetActivityExecutionOutcomeResponse)
+	err := c.cc.Invoke(ctx, ActivityService_GetActivityExecutionOutcome_FullMethodName, in, out, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -85,7 +96,8 @@ func (c *activityServiceClient) RequestCancelActivityExecution(ctx context.Conte
 // for forward compatibility
 type ActivityServiceServer interface {
 	StartActivityExecution(context.Context, *StartActivityExecutionRequest) (*StartActivityExecutionResponse, error)
-	PollActivityExecution(context.Context, *PollActivityExecutionRequest) (*PollActivityExecutionResponse, error)
+	DescribeActivityExecution(context.Context, *DescribeActivityExecutionRequest) (*DescribeActivityExecutionResponse, error)
+	GetActivityExecutionOutcome(context.Context, *GetActivityExecutionOutcomeRequest) (*GetActivityExecutionOutcomeResponse, error)
 	TerminateActivityExecution(context.Context, *TerminateActivityExecutionRequest) (*TerminateActivityExecutionResponse, error)
 	RequestCancelActivityExecution(context.Context, *RequestCancelActivityExecutionRequest) (*RequestCancelActivityExecutionResponse, error)
 	mustEmbedUnimplementedActivityServiceServer()
@@ -98,8 +110,11 @@ type UnimplementedActivityServiceServer struct {
 func (UnimplementedActivityServiceServer) StartActivityExecution(context.Context, *StartActivityExecutionRequest) (*StartActivityExecutionResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method StartActivityExecution not implemented")
 }
-func (UnimplementedActivityServiceServer) PollActivityExecution(context.Context, *PollActivityExecutionRequest) (*PollActivityExecutionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method PollActivityExecution not implemented")
+func (UnimplementedActivityServiceServer) DescribeActivityExecution(context.Context, *DescribeActivityExecutionRequest) (*DescribeActivityExecutionResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method DescribeActivityExecution not implemented")
+}
+func (UnimplementedActivityServiceServer) GetActivityExecutionOutcome(context.Context, *GetActivityExecutionOutcomeRequest) (*GetActivityExecutionOutcomeResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetActivityExecutionOutcome not implemented")
 }
 func (UnimplementedActivityServiceServer) TerminateActivityExecution(context.Context, *TerminateActivityExecutionRequest) (*TerminateActivityExecutionResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method TerminateActivityExecution not implemented")
@@ -138,20 +153,38 @@ func _ActivityService_StartActivityExecution_Handler(srv interface{}, ctx contex
 	return interceptor(ctx, in, info, handler)
 }
 
-func _ActivityService_PollActivityExecution_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(PollActivityExecutionRequest)
+func _ActivityService_DescribeActivityExecution_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DescribeActivityExecutionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ActivityServiceServer).DescribeActivityExecution(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: ActivityService_DescribeActivityExecution_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ActivityServiceServer).DescribeActivityExecution(ctx, req.(*DescribeActivityExecutionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _ActivityService_GetActivityExecutionOutcome_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetActivityExecutionOutcomeRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(ActivityServiceServer).PollActivityExecution(ctx, in)
+		return srv.(ActivityServiceServer).GetActivityExecutionOutcome(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: ActivityService_PollActivityExecution_FullMethodName,
+		FullMethod: ActivityService_GetActivityExecutionOutcome_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ActivityServiceServer).PollActivityExecution(ctx, req.(*PollActivityExecutionRequest))
+		return srv.(ActivityServiceServer).GetActivityExecutionOutcome(ctx, req.(*GetActivityExecutionOutcomeRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -204,8 +237,12 @@ var ActivityService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _ActivityService_StartActivityExecution_Handler,
 		},
 		{
-			MethodName: "PollActivityExecution",
-			Handler:    _ActivityService_PollActivityExecution_Handler,
+			MethodName: "DescribeActivityExecution",
+			Handler:    _ActivityService_DescribeActivityExecution_Handler,
+		},
+		{
+			MethodName: "GetActivityExecutionOutcome",
+			Handler:    _ActivityService_GetActivityExecutionOutcome_Handler,
 		},
 		{
 			MethodName: "TerminateActivityExecution",
diff --git a/chasm/lib/activity/handler.go b/chasm/lib/activity/handler.go
index 8c1431d0ec..73c0c999e1 100644
--- a/chasm/lib/activity/handler.go
+++ b/chasm/lib/activity/handler.go
@@ -88,20 +88,17 @@ func (h *handler) StartActivityExecution(ctx context.Context, req *activitypb.St
 	}, nil
 }
 
-// PollActivityExecution handles PollActivityExecutionRequest from frontend. This method supports
-// querying current activity state, optionally as a long-poll that waits for certain state changes.
-// It is used by clients to poll for activity state and/or result. When used to long-poll, it
-// returns an empty non-error response on context deadline expiry, to indicate that the state being
-// waited for was not reached. Callers should interpret this as an invitation to resubmit their
-// long-poll request. This response is sent before the caller's deadline (see
+// DescribeActivityExecution handles DescribeActivityExecutionRequest from frontend. This method
+// queries current activity state, optionally as a long-poll that waits for any state change. When
+// used to long-poll, it returns an empty non-error response on context deadline expiry, to indicate
+// that the state being waited for was not reached. Callers should interpret this as an invitation
+// to resubmit their long-poll request. This response is sent before the caller's deadline (see
 // chasm.activity.longPollBuffer) so that it is likely that the caller does indeed receive the
 // non-error response.
-//
-//nolint:revive // cognitive complexity
-func (h *handler) PollActivityExecution(
+func (h *handler) DescribeActivityExecution(
 	ctx context.Context,
-	req *activitypb.PollActivityExecutionRequest,
-) (response *activitypb.PollActivityExecutionResponse, err error) {
+	req *activitypb.DescribeActivityExecutionRequest,
+) (response *activitypb.DescribeActivityExecutionResponse, err error) {
 	ref := chasm.NewComponentRef[*Activity](chasm.ExecutionKey{
 		NamespaceID: req.GetNamespaceId(),
 		BusinessID:  req.GetFrontendRequest().GetActivityId(),
@@ -114,12 +111,6 @@ func (h *handler) PollActivityExecution(
 		}
 	}()
 
-	waitPolicy := req.GetFrontendRequest().GetWaitPolicy()
-
-	if waitPolicy == nil {
-		return chasm.ReadComponent(ctx, ref, (*Activity).buildPollActivityExecutionResponse, req, nil)
-	}
-
 	// Below, we send an empty non-error response on context deadline expiry. Here we compute a
 	// deadline that causes us to send that response before the caller's own deadline (see
 	// chasm.activity.longPollBuffer). We also cap the caller's deadline at
@@ -132,67 +123,91 @@ func (h *handler) PollActivityExecution(
 	)
 	defer cancel()
 
-	switch waitPolicyType := waitPolicy.(type) {
-	case *workflowservice.PollActivityExecutionRequest_WaitAnyStateChange:
-		token := waitPolicyType.WaitAnyStateChange.GetLongPollToken()
-		if len(token) == 0 {
-			return chasm.ReadComponent(ctx, ref, (*Activity).buildPollActivityExecutionResponse, req, nil)
-		}
-		response, _, err = chasm.PollComponent(ctx, ref, func(
-			a *Activity,
-			ctx chasm.Context,
-			req *activitypb.PollActivityExecutionRequest,
-		) (*activitypb.PollActivityExecutionResponse, bool, error) {
-			changed, err := chasm.ExecutionStateChanged(a, ctx, token)
-			if err != nil {
-				if errors.Is(err, chasm.ErrMalformedComponentRef) {
-					return nil, false, serviceerror.NewInvalidArgument("invalid long poll token")
-				}
-				if errors.Is(err, chasm.ErrInvalidComponentRef) {
-					return nil, false, serviceerror.NewInvalidArgument("long poll token does not match execution")
-				}
-				return nil, false, err
-			}
-			if changed {
-				response, err := a.buildPollActivityExecutionResponse(ctx, req)
-				return response, true, err
+	token := req.GetFrontendRequest().GetLongPollToken()
+	if len(token) == 0 {
+		return chasm.ReadComponent(ctx, ref, (*Activity).buildDescribeActivityExecutionResponse, req, nil)
+	}
+	response, _, err = chasm.PollComponent(ctx, ref, func(
+		a *Activity,
+		ctx chasm.Context,
+		req *activitypb.DescribeActivityExecutionRequest,
+	) (*activitypb.DescribeActivityExecutionResponse, bool, error) {
+		changed, err := chasm.ExecutionStateChanged(a, ctx, token)
+		if err != nil {
+			if errors.Is(err, chasm.ErrMalformedComponentRef) {
+				return nil, false, serviceerror.NewInvalidArgument("invalid long poll token")
 			}
-			return nil, false, nil
-		}, req)
-	case *workflowservice.PollActivityExecutionRequest_WaitCompletion:
-		// TODO(dan): add functional test when RecordActivityTaskCompleted is implemented
-		response, _, err = chasm.PollComponent(ctx, ref, func(
-			a *Activity,
-			ctx chasm.Context,
-			req *activitypb.PollActivityExecutionRequest,
-		) (*activitypb.PollActivityExecutionResponse, bool, error) {
-			if a.LifecycleState(ctx) != chasm.LifecycleStateRunning {
-				response, err := a.buildPollActivityExecutionResponse(ctx, req)
-				if err != nil {
-					return nil, true, err
-				}
-
-				return response, true, nil
+			if errors.Is(err, chasm.ErrInvalidComponentRef) {
+				return nil, false, serviceerror.NewInvalidArgument("long poll token does not match execution")
 			}
+			return nil, false, err
+		}
+		if changed {
+			response, err := a.buildDescribeActivityExecutionResponse(ctx, req)
+			return response, true, err
+		}
+		return nil, false, nil
+	}, req)
 
-			return nil, false, nil
-		}, req)
-	default:
-		return nil, serviceerror.NewInvalidArgumentf("unexpected wait policy type: %T", waitPolicy)
+	if err != nil && ctx.Err() != nil {
+		// Send empty non-error response on deadline expiry: caller should continue long-polling.
+		return &activitypb.DescribeActivityExecutionResponse{
+			FrontendResponse: &workflowservice.DescribeActivityExecutionResponse{},
+		}, nil
 	}
+	return response, err
+}
+
+// GetActivityExecutionOutcome handles getActivityExecutionOutcomeRequest from frontend. This method
+// long-polls for activity outcome. It returns an empty non-error response on context deadline
+// expiry, to indicate that the state being waited for was not reached. Callers should interpret
+// this as an invitation to resubmit their long-poll request. This response is sent before the
+// caller's deadline (see chasm.activity.longPollBuffer) so that it is likely that the caller does
+// indeed receive the non-error response.
+func (h *handler) GetActivityExecutionOutcome(
+	ctx context.Context,
+	req *activitypb.GetActivityExecutionOutcomeRequest,
+) (response *activitypb.GetActivityExecutionOutcomeResponse, err error) {
+	ref := chasm.NewComponentRef[*Activity](chasm.ExecutionKey{
+		NamespaceID: req.GetNamespaceId(),
+		BusinessID:  req.GetFrontendRequest().GetActivityId(),
+		RunID:       req.GetFrontendRequest().GetRunId(),
+	})
+	defer func() {
+		var notFound *serviceerror.NotFound
+		if errors.As(err, &notFound) {
+			err = serviceerror.NewNotFound("activity execution not found")
+		}
+	}()
+
+	// Below, we send an empty non-error response on context deadline expiry. Here we compute a
+	// deadline that causes us to send that response before the caller's own deadline (see
+	// chasm.activity.longPollBuffer). We also cap the caller's deadline at
+	// chasm.activity.longPollTimeout.
+	namespace := req.GetFrontendRequest().GetNamespace()
+	ctx, cancel := contextutil.WithDeadlineBuffer(
+		ctx,
+		h.config.LongPollTimeout(namespace),
+		h.config.LongPollBuffer(namespace),
+	)
+	defer cancel()
+
+	response, _, err = chasm.PollComponent(ctx, ref, func(
+		a *Activity,
+		ctx chasm.Context,
+		req *activitypb.GetActivityExecutionOutcomeRequest,
+	) (*activitypb.GetActivityExecutionOutcomeResponse, bool, error) {
+		if a.LifecycleState(ctx) != chasm.LifecycleStateRunning {
+			response, err := a.buildGetActivityExecutionOutcomeResponse(ctx)
+			return response, true, err
+		}
+		return nil, false, nil
+	}, req)
 
-	if ctx.Err() != nil {
-		// We send an empty non-error response on deadline expiry as an invitation to the caller to
-		// resubmit their long-poll.
-
-		// TODO(dan): the definition of "empty" is unclear, since callers can currently choose to
-		// exclude info, outcome, and input from the result. Currently, a caller can infer that the
-		// long-poll timed out due to a server-imposed timeout from the absence of the long-poll
-		// token. However, this is not a clear API. We are considering splitting the public API into
-		// two methods: one that returns info (optionally with input), and one that returns result,
-		// both with long-poll options. An empty response will then be more obvious to the caller.
-		return &activitypb.PollActivityExecutionResponse{
-			FrontendResponse: &workflowservice.PollActivityExecutionResponse{},
+	if err != nil && ctx.Err() != nil {
+		// Send an empty non-error response as an invitation to resubmit the long-poll.
+		return &activitypb.GetActivityExecutionOutcomeResponse{
+			FrontendResponse: &workflowservice.GetActivityExecutionOutcomeResponse{},
 		}, nil
 	}
 	return response, err
diff --git a/chasm/lib/activity/proto/v1/activity_state.proto b/chasm/lib/activity/proto/v1/activity_state.proto
index 7d2d365129..0962afe533 100644
--- a/chasm/lib/activity/proto/v1/activity_state.proto
+++ b/chasm/lib/activity/proto/v1/activity_state.proto
@@ -89,7 +89,7 @@ message ActivityState {
     ActivityExecutionStatus status = 8;
 
     // Time the activity was originally scheduled via a StartActivityExecution request.
-    google.protobuf.Timestamp scheduled_time = 9;
+    google.protobuf.Timestamp schedule_time = 9;
 
     // Priority metadata.
     temporal.api.common.v1.Priority priority = 10;
diff --git a/chasm/lib/activity/proto/v1/request_response.proto b/chasm/lib/activity/proto/v1/request_response.proto
index d3dbd15dea..fba062d6f3 100644
--- a/chasm/lib/activity/proto/v1/request_response.proto
+++ b/chasm/lib/activity/proto/v1/request_response.proto
@@ -16,29 +16,39 @@ message StartActivityExecutionResponse {
     temporal.api.workflowservice.v1.StartActivityExecutionResponse frontend_response = 1;
 }
 
-message PollActivityExecutionRequest {
+message DescribeActivityExecutionRequest {
     string namespace_id = 1;
 
-    temporal.api.workflowservice.v1.PollActivityExecutionRequest frontend_request = 2;
+    temporal.api.workflowservice.v1.DescribeActivityExecutionRequest frontend_request = 2;
 }
 
-message PollActivityExecutionResponse {
-    temporal.api.workflowservice.v1.PollActivityExecutionResponse frontend_response = 1;
+message DescribeActivityExecutionResponse {
+    temporal.api.workflowservice.v1.DescribeActivityExecutionResponse frontend_response = 1;
+}
+
+message GetActivityExecutionOutcomeRequest {
+    string namespace_id = 1;
+
+    temporal.api.workflowservice.v1.GetActivityExecutionOutcomeRequest frontend_request = 2;
+}
+
+message GetActivityExecutionOutcomeResponse {
+    temporal.api.workflowservice.v1.GetActivityExecutionOutcomeResponse frontend_response = 1;
 }
 
 message TerminateActivityExecutionRequest {
-  string namespace_id = 1;
+    string namespace_id = 1;
 
-  temporal.api.workflowservice.v1.TerminateActivityExecutionRequest frontend_request = 2;
+    temporal.api.workflowservice.v1.TerminateActivityExecutionRequest frontend_request = 2;
 }
 
 message TerminateActivityExecutionResponse {
 }
 
 message RequestCancelActivityExecutionRequest {
-  string namespace_id = 1;
+    string namespace_id = 1;
 
-  temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest frontend_request = 2;
+    temporal.api.workflowservice.v1.RequestCancelActivityExecutionRequest frontend_request = 2;
 }
 
 message RequestCancelActivityExecutionResponse {
diff --git a/chasm/lib/activity/proto/v1/service.proto b/chasm/lib/activity/proto/v1/service.proto
index 48fa6612d3..6a44f9654d 100644
--- a/chasm/lib/activity/proto/v1/service.proto
+++ b/chasm/lib/activity/proto/v1/service.proto
@@ -12,15 +12,19 @@ service ActivityService {
         option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
     }
 
-    rpc PollActivityExecution(PollActivityExecutionRequest) returns (PollActivityExecutionResponse) {
-      option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
+    rpc DescribeActivityExecution(DescribeActivityExecutionRequest) returns (DescribeActivityExecutionResponse) {
+        option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
+    }
+
+    rpc GetActivityExecutionOutcome(GetActivityExecutionOutcomeRequest) returns (GetActivityExecutionOutcomeResponse) {
+        option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
     }
 
     rpc TerminateActivityExecution(TerminateActivityExecutionRequest) returns (TerminateActivityExecutionResponse) {
-      option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
+        option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
     }
 
-  rpc RequestCancelActivityExecution(RequestCancelActivityExecutionRequest) returns (RequestCancelActivityExecutionResponse) {
-    option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
-  }
+    rpc RequestCancelActivityExecution(RequestCancelActivityExecutionRequest) returns (RequestCancelActivityExecutionResponse) {
+        option (temporal.server.api.routing.v1.routing).business_id = "frontend_request.activity_id";
+    }
 }
diff --git a/chasm/lib/activity/proto/v1/tasks.proto b/chasm/lib/activity/proto/v1/tasks.proto
index 8015d8134a..4c786d6b00 100644
--- a/chasm/lib/activity/proto/v1/tasks.proto
+++ b/chasm/lib/activity/proto/v1/tasks.proto
@@ -11,16 +11,16 @@ message ActivityDispatchTask {
 }
 
 message ScheduleToStartTimeoutTask {
-  // The current attempt number for this activity execution. Since task validation/exec happen outside of a lock, we
-  // need to guard against any concurrent operations where the originally intended task may be outdated.
-  int32 attempt = 1;
+    // The current attempt number for this activity execution. Since task validation/exec happen outside of a lock, we
+    // need to guard against any concurrent operations where the originally intended task may be outdated.
+    int32 attempt = 1;
 }
 
 message ScheduleToCloseTimeoutTask {
 }
 
 message StartToCloseTimeoutTask {
-  // The current attempt number for this activity execution. Since task validation/exec happen outside of a lock, we
-  // need to guard against any concurrent operations where the originally intended task may be outdated.
-  int32 attempt = 1;
+    // The current attempt number for this activity execution. Since task validation/exec happen outside of a lock, we
+    // need to guard against any concurrent operations where the originally intended task may be outdated.
+    int32 attempt = 1;
 }
\ No newline at end of file
diff --git a/chasm/lib/activity/validator.go b/chasm/lib/activity/validator.go
index 7069272bd4..885199aa89 100644
--- a/chasm/lib/activity/validator.go
+++ b/chasm/lib/activity/validator.go
@@ -259,9 +259,9 @@ func validateAndNormalizeSearchAttributes(
 	return saValidator.ValidateSize(req.SearchAttributes, namespaceName)
 }
 
-// ValidatePollActivityExecutionRequest validates the request for PollActivityExecution API.
-func ValidatePollActivityExecutionRequest(
-	req *workflowservice.PollActivityExecutionRequest,
+// ValidateDescribeActivityExecutionRequest validates DescribeActivityExecutionRequest.
+func ValidateDescribeActivityExecutionRequest(
+	req *workflowservice.DescribeActivityExecutionRequest,
 	maxIDLengthLimit int,
 ) error {
 	if req.GetActivityId() == "" {
@@ -272,7 +272,7 @@ func ValidatePollActivityExecutionRequest(
 			len(req.GetActivityId()), maxIDLengthLimit)
 	}
 	hasRunID := req.GetRunId() != ""
-	hasLongPollToken := len(req.GetWaitAnyStateChange().GetLongPollToken()) > 0
+	hasLongPollToken := len(req.GetLongPollToken()) > 0
 
 	if hasLongPollToken && !hasRunID {
 		return serviceerror.NewInvalidArgument("run id is required when long poll token is provided")
@@ -285,3 +285,24 @@ func ValidatePollActivityExecutionRequest(
 	}
 	return nil
 }
+
+// ValidateGetActivityExecutionOutcomeRequest validates GetActivityExecutionOutcomeRequest.
+func ValidateGetActivityExecutionOutcomeRequest(
+	req *workflowservice.GetActivityExecutionOutcomeRequest,
+	maxIDLengthLimit int,
+) error {
+	if req.GetActivityId() == "" {
+		return serviceerror.NewInvalidArgument("activity ID is required")
+	}
+	if len(req.GetActivityId()) > maxIDLengthLimit {
+		return serviceerror.NewInvalidArgumentf("activity ID exceeds length limit. Length=%d Limit=%d",
+			len(req.GetActivityId()), maxIDLengthLimit)
+	}
+	if runID := req.GetRunId(); runID != "" {
+		_, err := uuid.Parse(runID)
+		if err != nil {
+			return serviceerror.NewInvalidArgument("invalid run id: must be a valid UUID")
+		}
+	}
+	return nil
+}
diff --git a/chasm/lib/activity/validator_test.go b/chasm/lib/activity/validator_test.go
index 4453ce3d1d..d64403916f 100644
--- a/chasm/lib/activity/validator_test.go
+++ b/chasm/lib/activity/validator_test.go
@@ -221,10 +221,14 @@ func TestValidateStandAloneRequestIDTooLong(t *testing.T) {
 	req := &workflowservice.StartActivityExecutionRequest{
 		ActivityId:   defaultActivityID,
 		ActivityType: &commonpb.ActivityType{Name: defaultActivityType},
-		Options:      &defaultActivityOptions,
-		Namespace:    "default",
-		RequestId:    string(make([]byte, 1001)),
-		Input:        payloads.EncodeString("test-input"),
+		RetryPolicy: &commonpb.RetryPolicy{
+			InitialInterval: durationpb.New(1 * time.Second),
+		},
+		ScheduleToCloseTimeout: durationpb.New(10 * time.Second),
+		TaskQueue:              &taskqueuepb.TaskQueue{Name: defaultTaskQueue},
+		Namespace:              "default",
+		RequestId:              string(make([]byte, 1001)),
+		Input:                  payloads.EncodeString("test-input"),
 	}
 
 	err := validateAndNormalizeStartActivityExecutionRequest(
@@ -242,10 +246,14 @@ func TestValidateStandAloneInputTooLarge(t *testing.T) {
 	req := &workflowservice.StartActivityExecutionRequest{
 		ActivityId:   defaultActivityID,
 		ActivityType: &commonpb.ActivityType{Name: defaultActivityType},
-		Options:      &defaultActivityOptions,
-		Namespace:    "default",
-		RequestId:    "test-request-id",
-		Input:        payloads.EncodeString(string(make([]byte, 1000))),
+		RetryPolicy: &commonpb.RetryPolicy{
+			InitialInterval: durationpb.New(1 * time.Second),
+		},
+		ScheduleToCloseTimeout: durationpb.New(10 * time.Second),
+		TaskQueue:              &taskqueuepb.TaskQueue{Name: defaultTaskQueue},
+		Namespace:              "default",
+		RequestId:              "test-request-id",
+		Input:                  payloads.EncodeString(string(make([]byte, 1000))),
 	}
 
 	err := validateAndNormalizeStartActivityExecutionRequest(
@@ -266,10 +274,14 @@ func TestValidateStandAloneInputWarningSizeShouldSucceed(t *testing.T) {
 	req := &workflowservice.StartActivityExecutionRequest{
 		ActivityId:   defaultActivityID,
 		ActivityType: &commonpb.ActivityType{Name: defaultActivityType},
-		Options:      &defaultActivityOptions,
-		Namespace:    "default",
-		RequestId:    "test-request-id",
-		Input:        payload,
+		RetryPolicy: &commonpb.RetryPolicy{
+			InitialInterval: durationpb.New(1 * time.Second),
+		},
+		ScheduleToCloseTimeout: durationpb.New(10 * time.Second),
+		TaskQueue:              &taskqueuepb.TaskQueue{Name: defaultTaskQueue},
+		Namespace:              "default",
+		RequestId:              "test-request-id",
+		Input:                  payload,
 	}
 
 	err := validateAndNormalizeStartActivityExecutionRequest(
@@ -286,9 +298,13 @@ func TestValidateStandAlone_IDPolicyShouldDefault(t *testing.T) {
 	req := &workflowservice.StartActivityExecutionRequest{
 		ActivityId:   defaultActivityID,
 		ActivityType: &commonpb.ActivityType{Name: defaultActivityType},
-		Options:      &defaultActivityOptions,
-		Namespace:    "default",
-		RequestId:    "test-request-id",
+		RetryPolicy: &commonpb.RetryPolicy{
+			InitialInterval: durationpb.New(1 * time.Second),
+		},
+		ScheduleToCloseTimeout: durationpb.New(10 * time.Second),
+		TaskQueue:              &taskqueuepb.TaskQueue{Name: defaultTaskQueue},
+		Namespace:              "default",
+		RequestId:              "test-request-id",
 	}
 
 	err := validateAndNormalizeStartActivityExecutionRequest(
diff --git a/client/frontend/client_gen.go b/client/frontend/client_gen.go
index 8581241351..ca4a048085 100644
--- a/client/frontend/client_gen.go
+++ b/client/frontend/client_gen.go
@@ -119,6 +119,16 @@ func (c *clientImpl) DeprecateNamespace(
 	return c.client.DeprecateNamespace(ctx, request, opts...)
 }
 
+func (c *clientImpl) DescribeActivityExecution(
+	ctx context.Context,
+	request *workflowservice.DescribeActivityExecutionRequest,
+	opts ...grpc.CallOption,
+) (*workflowservice.DescribeActivityExecutionResponse, error) {
+	ctx, cancel := c.createContext(ctx)
+	defer cancel()
+	return c.client.DescribeActivityExecution(ctx, request, opts...)
+}
+
 func (c *clientImpl) DescribeBatchOperation(
 	ctx context.Context,
 	request *workflowservice.DescribeBatchOperationRequest,
@@ -239,6 +249,16 @@ func (c *clientImpl) FetchWorkerConfig(
 	return c.client.FetchWorkerConfig(ctx, request, opts...)
 }
 
+func (c *clientImpl) GetActivityExecutionOutcome(
+	ctx context.Context,
+	request *workflowservice.GetActivityExecutionOutcomeRequest,
+	opts ...grpc.CallOption,
+) (*workflowservice.GetActivityExecutionOutcomeResponse, error) {
+	ctx, cancel := c.createContext(ctx)
+	defer cancel()
+	return c.client.GetActivityExecutionOutcome(ctx, request, opts...)
+}
+
 func (c *clientImpl) GetClusterInfo(
 	ctx context.Context,
 	request *workflowservice.GetClusterInfoRequest,
@@ -499,16 +519,6 @@ func (c *clientImpl) PauseActivity(
 	return c.client.PauseActivity(ctx, request, opts...)
 }
 
-func (c *clientImpl) PauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PauseActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.PauseActivityExecutionResponse, error) {
-	ctx, cancel := c.createContext(ctx)
-	defer cancel()
-	return c.client.PauseActivityExecution(ctx, request, opts...)
-}
-
 func (c *clientImpl) PauseWorkflowExecution(
 	ctx context.Context,
 	request *workflowservice.PauseWorkflowExecutionRequest,
@@ -519,16 +529,6 @@ func (c *clientImpl) PauseWorkflowExecution(
 	return c.client.PauseWorkflowExecution(ctx, request, opts...)
 }
 
-func (c *clientImpl) PollActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PollActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.PollActivityExecutionResponse, error) {
-	ctx, cancel := c.createContext(ctx)
-	defer cancel()
-	return c.client.PollActivityExecution(ctx, request, opts...)
-}
-
 func (c *clientImpl) PollActivityTaskQueue(
 	ctx context.Context,
 	request *workflowservice.PollActivityTaskQueueRequest,
@@ -649,16 +649,6 @@ func (c *clientImpl) ResetActivity(
 	return c.client.ResetActivity(ctx, request, opts...)
 }
 
-func (c *clientImpl) ResetActivityExecution(
-	ctx context.Context,
-	request *workflowservice.ResetActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.ResetActivityExecutionResponse, error) {
-	ctx, cancel := c.createContext(ctx)
-	defer cancel()
-	return c.client.ResetActivityExecution(ctx, request, opts...)
-}
-
 func (c *clientImpl) ResetStickyTaskQueue(
 	ctx context.Context,
 	request *workflowservice.ResetStickyTaskQueueRequest,
@@ -949,16 +939,6 @@ func (c *clientImpl) UnpauseActivity(
 	return c.client.UnpauseActivity(ctx, request, opts...)
 }
 
-func (c *clientImpl) UnpauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.UnpauseActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.UnpauseActivityExecutionResponse, error) {
-	ctx, cancel := c.createContext(ctx)
-	defer cancel()
-	return c.client.UnpauseActivityExecution(ctx, request, opts...)
-}
-
 func (c *clientImpl) UnpauseWorkflowExecution(
 	ctx context.Context,
 	request *workflowservice.UnpauseWorkflowExecutionRequest,
@@ -969,16 +949,6 @@ func (c *clientImpl) UnpauseWorkflowExecution(
 	return c.client.UnpauseWorkflowExecution(ctx, request, opts...)
 }
 
-func (c *clientImpl) UpdateActivityExecutionOptions(
-	ctx context.Context,
-	request *workflowservice.UpdateActivityExecutionOptionsRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) {
-	ctx, cancel := c.createContext(ctx)
-	defer cancel()
-	return c.client.UpdateActivityExecutionOptions(ctx, request, opts...)
-}
-
 func (c *clientImpl) UpdateActivityOptions(
 	ctx context.Context,
 	request *workflowservice.UpdateActivityOptionsRequest,
diff --git a/client/frontend/metric_client_gen.go b/client/frontend/metric_client_gen.go
index afa54c8e7f..6aa85e33ae 100644
--- a/client/frontend/metric_client_gen.go
+++ b/client/frontend/metric_client_gen.go
@@ -163,6 +163,20 @@ func (c *metricClient) DeprecateNamespace(
 	return c.client.DeprecateNamespace(ctx, request, opts...)
 }
 
+func (c *metricClient) DescribeActivityExecution(
+	ctx context.Context,
+	request *workflowservice.DescribeActivityExecutionRequest,
+	opts ...grpc.CallOption,
+) (_ *workflowservice.DescribeActivityExecutionResponse, retError error) {
+
+	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientDescribeActivityExecution")
+	defer func() {
+		c.finishMetricsRecording(metricsHandler, startTime, retError)
+	}()
+
+	return c.client.DescribeActivityExecution(ctx, request, opts...)
+}
+
 func (c *metricClient) DescribeBatchOperation(
 	ctx context.Context,
 	request *workflowservice.DescribeBatchOperationRequest,
@@ -331,6 +345,20 @@ func (c *metricClient) FetchWorkerConfig(
 	return c.client.FetchWorkerConfig(ctx, request, opts...)
 }
 
+func (c *metricClient) GetActivityExecutionOutcome(
+	ctx context.Context,
+	request *workflowservice.GetActivityExecutionOutcomeRequest,
+	opts ...grpc.CallOption,
+) (_ *workflowservice.GetActivityExecutionOutcomeResponse, retError error) {
+
+	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientGetActivityExecutionOutcome")
+	defer func() {
+		c.finishMetricsRecording(metricsHandler, startTime, retError)
+	}()
+
+	return c.client.GetActivityExecutionOutcome(ctx, request, opts...)
+}
+
 func (c *metricClient) GetClusterInfo(
 	ctx context.Context,
 	request *workflowservice.GetClusterInfoRequest,
@@ -695,20 +723,6 @@ func (c *metricClient) PauseActivity(
 	return c.client.PauseActivity(ctx, request, opts...)
 }
 
-func (c *metricClient) PauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PauseActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (_ *workflowservice.PauseActivityExecutionResponse, retError error) {
-
-	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientPauseActivityExecution")
-	defer func() {
-		c.finishMetricsRecording(metricsHandler, startTime, retError)
-	}()
-
-	return c.client.PauseActivityExecution(ctx, request, opts...)
-}
-
 func (c *metricClient) PauseWorkflowExecution(
 	ctx context.Context,
 	request *workflowservice.PauseWorkflowExecutionRequest,
@@ -723,20 +737,6 @@ func (c *metricClient) PauseWorkflowExecution(
 	return c.client.PauseWorkflowExecution(ctx, request, opts...)
 }
 
-func (c *metricClient) PollActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PollActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (_ *workflowservice.PollActivityExecutionResponse, retError error) {
-
-	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientPollActivityExecution")
-	defer func() {
-		c.finishMetricsRecording(metricsHandler, startTime, retError)
-	}()
-
-	return c.client.PollActivityExecution(ctx, request, opts...)
-}
-
 func (c *metricClient) PollActivityTaskQueue(
 	ctx context.Context,
 	request *workflowservice.PollActivityTaskQueueRequest,
@@ -905,20 +905,6 @@ func (c *metricClient) ResetActivity(
 	return c.client.ResetActivity(ctx, request, opts...)
 }
 
-func (c *metricClient) ResetActivityExecution(
-	ctx context.Context,
-	request *workflowservice.ResetActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (_ *workflowservice.ResetActivityExecutionResponse, retError error) {
-
-	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientResetActivityExecution")
-	defer func() {
-		c.finishMetricsRecording(metricsHandler, startTime, retError)
-	}()
-
-	return c.client.ResetActivityExecution(ctx, request, opts...)
-}
-
 func (c *metricClient) ResetStickyTaskQueue(
 	ctx context.Context,
 	request *workflowservice.ResetStickyTaskQueueRequest,
@@ -1325,20 +1311,6 @@ func (c *metricClient) UnpauseActivity(
 	return c.client.UnpauseActivity(ctx, request, opts...)
 }
 
-func (c *metricClient) UnpauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.UnpauseActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (_ *workflowservice.UnpauseActivityExecutionResponse, retError error) {
-
-	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientUnpauseActivityExecution")
-	defer func() {
-		c.finishMetricsRecording(metricsHandler, startTime, retError)
-	}()
-
-	return c.client.UnpauseActivityExecution(ctx, request, opts...)
-}
-
 func (c *metricClient) UnpauseWorkflowExecution(
 	ctx context.Context,
 	request *workflowservice.UnpauseWorkflowExecutionRequest,
@@ -1353,20 +1325,6 @@ func (c *metricClient) UnpauseWorkflowExecution(
 	return c.client.UnpauseWorkflowExecution(ctx, request, opts...)
 }
 
-func (c *metricClient) UpdateActivityExecutionOptions(
-	ctx context.Context,
-	request *workflowservice.UpdateActivityExecutionOptionsRequest,
-	opts ...grpc.CallOption,
-) (_ *workflowservice.UpdateActivityExecutionOptionsResponse, retError error) {
-
-	metricsHandler, startTime := c.startMetricsRecording(ctx, "FrontendClientUpdateActivityExecutionOptions")
-	defer func() {
-		c.finishMetricsRecording(metricsHandler, startTime, retError)
-	}()
-
-	return c.client.UpdateActivityExecutionOptions(ctx, request, opts...)
-}
-
 func (c *metricClient) UpdateActivityOptions(
 	ctx context.Context,
 	request *workflowservice.UpdateActivityOptionsRequest,
diff --git a/client/frontend/retryable_client_gen.go b/client/frontend/retryable_client_gen.go
index b086c655a6..9282e13e50 100644
--- a/client/frontend/retryable_client_gen.go
+++ b/client/frontend/retryable_client_gen.go
@@ -176,6 +176,21 @@ func (c *retryableClient) DeprecateNamespace(
 	return resp, err
 }
 
+func (c *retryableClient) DescribeActivityExecution(
+	ctx context.Context,
+	request *workflowservice.DescribeActivityExecutionRequest,
+	opts ...grpc.CallOption,
+) (*workflowservice.DescribeActivityExecutionResponse, error) {
+	var resp *workflowservice.DescribeActivityExecutionResponse
+	op := func(ctx context.Context) error {
+		var err error
+		resp, err = c.client.DescribeActivityExecution(ctx, request, opts...)
+		return err
+	}
+	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
+	return resp, err
+}
+
 func (c *retryableClient) DescribeBatchOperation(
 	ctx context.Context,
 	request *workflowservice.DescribeBatchOperationRequest,
@@ -356,6 +371,21 @@ func (c *retryableClient) FetchWorkerConfig(
 	return resp, err
 }
 
+func (c *retryableClient) GetActivityExecutionOutcome(
+	ctx context.Context,
+	request *workflowservice.GetActivityExecutionOutcomeRequest,
+	opts ...grpc.CallOption,
+) (*workflowservice.GetActivityExecutionOutcomeResponse, error) {
+	var resp *workflowservice.GetActivityExecutionOutcomeResponse
+	op := func(ctx context.Context) error {
+		var err error
+		resp, err = c.client.GetActivityExecutionOutcome(ctx, request, opts...)
+		return err
+	}
+	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
+	return resp, err
+}
+
 func (c *retryableClient) GetClusterInfo(
 	ctx context.Context,
 	request *workflowservice.GetClusterInfoRequest,
@@ -746,21 +776,6 @@ func (c *retryableClient) PauseActivity(
 	return resp, err
 }
 
-func (c *retryableClient) PauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PauseActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.PauseActivityExecutionResponse, error) {
-	var resp *workflowservice.PauseActivityExecutionResponse
-	op := func(ctx context.Context) error {
-		var err error
-		resp, err = c.client.PauseActivityExecution(ctx, request, opts...)
-		return err
-	}
-	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
-	return resp, err
-}
-
 func (c *retryableClient) PauseWorkflowExecution(
 	ctx context.Context,
 	request *workflowservice.PauseWorkflowExecutionRequest,
@@ -776,21 +791,6 @@ func (c *retryableClient) PauseWorkflowExecution(
 	return resp, err
 }
 
-func (c *retryableClient) PollActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PollActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.PollActivityExecutionResponse, error) {
-	var resp *workflowservice.PollActivityExecutionResponse
-	op := func(ctx context.Context) error {
-		var err error
-		resp, err = c.client.PollActivityExecution(ctx, request, opts...)
-		return err
-	}
-	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
-	return resp, err
-}
-
 func (c *retryableClient) PollActivityTaskQueue(
 	ctx context.Context,
 	request *workflowservice.PollActivityTaskQueueRequest,
@@ -971,21 +971,6 @@ func (c *retryableClient) ResetActivity(
 	return resp, err
 }
 
-func (c *retryableClient) ResetActivityExecution(
-	ctx context.Context,
-	request *workflowservice.ResetActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.ResetActivityExecutionResponse, error) {
-	var resp *workflowservice.ResetActivityExecutionResponse
-	op := func(ctx context.Context) error {
-		var err error
-		resp, err = c.client.ResetActivityExecution(ctx, request, opts...)
-		return err
-	}
-	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
-	return resp, err
-}
-
 func (c *retryableClient) ResetStickyTaskQueue(
 	ctx context.Context,
 	request *workflowservice.ResetStickyTaskQueueRequest,
@@ -1421,21 +1406,6 @@ func (c *retryableClient) UnpauseActivity(
 	return resp, err
 }
 
-func (c *retryableClient) UnpauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.UnpauseActivityExecutionRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.UnpauseActivityExecutionResponse, error) {
-	var resp *workflowservice.UnpauseActivityExecutionResponse
-	op := func(ctx context.Context) error {
-		var err error
-		resp, err = c.client.UnpauseActivityExecution(ctx, request, opts...)
-		return err
-	}
-	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
-	return resp, err
-}
-
 func (c *retryableClient) UnpauseWorkflowExecution(
 	ctx context.Context,
 	request *workflowservice.UnpauseWorkflowExecutionRequest,
@@ -1451,21 +1421,6 @@ func (c *retryableClient) UnpauseWorkflowExecution(
 	return resp, err
 }
 
-func (c *retryableClient) UpdateActivityExecutionOptions(
-	ctx context.Context,
-	request *workflowservice.UpdateActivityExecutionOptionsRequest,
-	opts ...grpc.CallOption,
-) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) {
-	var resp *workflowservice.UpdateActivityExecutionOptionsResponse
-	op := func(ctx context.Context) error {
-		var err error
-		resp, err = c.client.UpdateActivityExecutionOptions(ctx, request, opts...)
-		return err
-	}
-	err := backoff.ThrottleRetryContext(ctx, op, c.policy, c.isRetryable)
-	return resp, err
-}
-
 func (c *retryableClient) UpdateActivityOptions(
 	ctx context.Context,
 	request *workflowservice.UpdateActivityOptionsRequest,
diff --git a/common/api/metadata.go b/common/api/metadata.go
index 5f3fd85923..6c3cf0cb74 100644
--- a/common/api/metadata.go
+++ b/common/api/metadata.go
@@ -90,15 +90,12 @@ var (
 		"RespondActivityTaskCanceledById":       {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
 		"CountActivityExecutions":               {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingNone},
 		"DeleteActivityExecution":               {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
-		"PollActivityExecution":                 {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingCapable},
+		"DescribeActivityExecution":             {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingCapable},
+		"GetActivityExecutionOutcome":           {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingAlways},
 		"ListActivityExecutions":                {Scope: ScopeNamespace, Access: AccessReadOnly, Polling: PollingNone},
-		"PauseActivityExecution":                {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
 		"RequestCancelActivityExecution":        {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
-		"ResetActivityExecution":                {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
 		"StartActivityExecution":                {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
 		"TerminateActivityExecution":            {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
-		"UnpauseActivityExecution":              {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
-		"UpdateActivityExecutionOptions":        {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
 		"PollNexusTaskQueue":                    {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingAlways},
 		"RespondNexusTaskCompleted":             {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
 		"RespondNexusTaskFailed":                {Scope: ScopeNamespace, Access: AccessWrite, Polling: PollingNone},
diff --git a/common/rpc/interceptor/logtags/workflow_service_server_gen.go b/common/rpc/interceptor/logtags/workflow_service_server_gen.go
index caf9d209c8..e7ebb2ee70 100644
--- a/common/rpc/interceptor/logtags/workflow_service_server_gen.go
+++ b/common/rpc/interceptor/logtags/workflow_service_server_gen.go
@@ -58,6 +58,14 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		return nil
 	case *workflowservice.DeprecateNamespaceResponse:
 		return nil
+	case *workflowservice.DescribeActivityExecutionRequest:
+		return []tag.Tag{
+			tag.WorkflowRunID(r.GetRunId()),
+		}
+	case *workflowservice.DescribeActivityExecutionResponse:
+		return []tag.Tag{
+			tag.WorkflowRunID(r.GetRunId()),
+		}
 	case *workflowservice.DescribeBatchOperationRequest:
 		return nil
 	case *workflowservice.DescribeBatchOperationResponse:
@@ -109,6 +117,14 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		return nil
 	case *workflowservice.FetchWorkerConfigResponse:
 		return nil
+	case *workflowservice.GetActivityExecutionOutcomeRequest:
+		return []tag.Tag{
+			tag.WorkflowRunID(r.GetRunId()),
+		}
+	case *workflowservice.GetActivityExecutionOutcomeResponse:
+		return []tag.Tag{
+			tag.WorkflowRunID(r.GetRunId()),
+		}
 	case *workflowservice.GetClusterInfoRequest:
 		return nil
 	case *workflowservice.GetClusterInfoResponse:
@@ -222,13 +238,6 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		}
 	case *workflowservice.PauseActivityResponse:
 		return nil
-	case *workflowservice.PauseActivityExecutionRequest:
-		return []tag.Tag{
-			tag.WorkflowID(r.GetWorkflowId()),
-			tag.WorkflowRunID(r.GetRunId()),
-		}
-	case *workflowservice.PauseActivityExecutionResponse:
-		return nil
 	case *workflowservice.PauseWorkflowExecutionRequest:
 		return []tag.Tag{
 			tag.WorkflowID(r.GetWorkflowId()),
@@ -236,14 +245,6 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		}
 	case *workflowservice.PauseWorkflowExecutionResponse:
 		return nil
-	case *workflowservice.PollActivityExecutionRequest:
-		return []tag.Tag{
-			tag.WorkflowRunID(r.GetRunId()),
-		}
-	case *workflowservice.PollActivityExecutionResponse:
-		return []tag.Tag{
-			tag.WorkflowRunID(r.GetRunId()),
-		}
 	case *workflowservice.PollActivityTaskQueueRequest:
 		return nil
 	case *workflowservice.PollActivityTaskQueueResponse:
@@ -318,13 +319,6 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		}
 	case *workflowservice.ResetActivityResponse:
 		return nil
-	case *workflowservice.ResetActivityExecutionRequest:
-		return []tag.Tag{
-			tag.WorkflowID(r.GetWorkflowId()),
-			tag.WorkflowRunID(r.GetRunId()),
-		}
-	case *workflowservice.ResetActivityExecutionResponse:
-		return nil
 	case *workflowservice.ResetStickyTaskQueueRequest:
 		return []tag.Tag{
 			tag.WorkflowID(r.GetExecution().GetWorkflowId()),
@@ -482,13 +476,6 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		}
 	case *workflowservice.UnpauseActivityResponse:
 		return nil
-	case *workflowservice.UnpauseActivityExecutionRequest:
-		return []tag.Tag{
-			tag.WorkflowID(r.GetWorkflowId()),
-			tag.WorkflowRunID(r.GetRunId()),
-		}
-	case *workflowservice.UnpauseActivityExecutionResponse:
-		return nil
 	case *workflowservice.UnpauseWorkflowExecutionRequest:
 		return []tag.Tag{
 			tag.WorkflowID(r.GetWorkflowId()),
@@ -496,13 +483,6 @@ func (wt *WorkflowTags) extractFromWorkflowServiceServerMessage(message any) []t
 		}
 	case *workflowservice.UnpauseWorkflowExecutionResponse:
 		return nil
-	case *workflowservice.UpdateActivityExecutionOptionsRequest:
-		return []tag.Tag{
-			tag.WorkflowID(r.GetWorkflowId()),
-			tag.WorkflowRunID(r.GetRunId()),
-		}
-	case *workflowservice.UpdateActivityExecutionOptionsResponse:
-		return nil
 	case *workflowservice.UpdateActivityOptionsRequest:
 		return []tag.Tag{
 			tag.WorkflowID(r.GetExecution().GetWorkflowId()),
diff --git a/common/rpc/interceptor/namespace_rate_limit.go b/common/rpc/interceptor/namespace_rate_limit.go
index e4ca7f9615..a67ee7782d 100644
--- a/common/rpc/interceptor/namespace_rate_limit.go
+++ b/common/rpc/interceptor/namespace_rate_limit.go
@@ -64,8 +64,10 @@ func (ni *NamespaceRateLimitInterceptorImpl) Intercept(
 ) (interface{}, error) {
 	if ns := MustGetNamespaceName(ni.namespaceRegistry, req); ns != namespace.EmptyName {
 		method := info.FullMethod
-		if IsLongPollGetHistoryRequest(req) {
+		if IsLongPollGetWorkflowExecutionHistoryRequest(req) {
 			method = configs.PollWorkflowHistoryAPIName
+		} else if IsLongPollDescribeActivityExecutionRequest(req) {
+			method = configs.PollActivityExecutionAPIName
 		}
 		if err := ni.Allow(ns, method, headers.NewGRPCHeaderGetter(ctx)); err != nil {
 			return nil, err
@@ -94,7 +96,7 @@ func (ni *NamespaceRateLimitInterceptorImpl) Allow(namespaceName namespace.Name,
 	return nil
 }
 
-func IsLongPollGetHistoryRequest(
+func IsLongPollGetWorkflowExecutionHistoryRequest(
 	req interface{},
 ) bool {
 	switch request := req.(type) {
@@ -103,3 +105,13 @@ func IsLongPollGetHistoryRequest(
 	}
 	return false
 }
+
+func IsLongPollDescribeActivityExecutionRequest(
+	req interface{},
+) bool {
+	switch request := req.(type) {
+	case *workflowservice.DescribeActivityExecutionRequest:
+		return len(request.GetLongPollToken()) > 0
+	}
+	return false
+}
diff --git a/common/rpc/interceptor/redirection.go b/common/rpc/interceptor/redirection.go
index f046c30ddb..5a42ee5a47 100644
--- a/common/rpc/interceptor/redirection.go
+++ b/common/rpc/interceptor/redirection.go
@@ -141,14 +141,11 @@ var (
 		"StartActivityExecution":         func() any { return &workflowservice.StartActivityExecutionResponse{} },
 		"CountActivityExecutions":        func() any { return &workflowservice.CountActivityExecutionsResponse{} },
 		"ListActivityExecutions":         func() any { return &workflowservice.ListActivityExecutionsResponse{} },
-		"PollActivityExecution":          func() any { return &workflowservice.PollActivityExecutionResponse{} },
+		"DescribeActivityExecution":      func() any { return &workflowservice.DescribeActivityExecutionResponse{} },
+		"GetActivityExecutionOutcome":    func() any { return &workflowservice.GetActivityExecutionOutcomeResponse{} },
 		"RequestCancelActivityExecution": func() any { return &workflowservice.RequestCancelActivityExecutionResponse{} },
 		"TerminateActivityExecution":     func() any { return &workflowservice.TerminateActivityExecutionResponse{} },
 		"DeleteActivityExecution":        func() any { return &workflowservice.DeleteActivityExecutionResponse{} },
-		"PauseActivityExecution":         func() any { return &workflowservice.PauseActivityExecutionResponse{} },
-		"UnpauseActivityExecution":       func() any { return &workflowservice.UnpauseActivityExecutionResponse{} },
-		"UpdateActivityExecutionOptions": func() any { return &workflowservice.UpdateActivityExecutionOptionsResponse{} },
-		"ResetActivityExecution":         func() any { return &workflowservice.ResetActivityExecutionResponse{} },
 	}
 )
 
diff --git a/common/rpc/interceptor/redirection_test.go b/common/rpc/interceptor/redirection_test.go
index 306a8176e2..5568719650 100644
--- a/common/rpc/interceptor/redirection_test.go
+++ b/common/rpc/interceptor/redirection_test.go
@@ -196,14 +196,11 @@ func (s *redirectionInterceptorSuite) TestGlobalAPI() {
 		"StartActivityExecution":         {},
 		"CountActivityExecutions":        {},
 		"ListActivityExecutions":         {},
-		"PollActivityExecution":          {},
+		"DescribeActivityExecution":      {},
+		"GetActivityExecutionOutcome":    {},
 		"RequestCancelActivityExecution": {},
 		"TerminateActivityExecution":     {},
 		"DeleteActivityExecution":        {},
-		"PauseActivityExecution":         {},
-		"UnpauseActivityExecution":       {},
-		"UpdateActivityExecutionOptions": {},
-		"ResetActivityExecution":         {},
 	}, apis)
 }
 
diff --git a/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go b/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go
index 4d0086b570..8bea4d1ad6 100644
--- a/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go
+++ b/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go
@@ -262,6 +262,26 @@ func (mr *MockWorkflowServiceClientMockRecorder) DeprecateNamespace(ctx, in any,
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprecateNamespace", reflect.TypeOf((*MockWorkflowServiceClient)(nil).DeprecateNamespace), varargs...)
 }
 
+// DescribeActivityExecution mocks base method.
+func (m *MockWorkflowServiceClient) DescribeActivityExecution(ctx context.Context, in *workflowservice.DescribeActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.DescribeActivityExecutionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeActivityExecution", varargs...)
+	ret0, _ := ret[0].(*workflowservice.DescribeActivityExecutionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeActivityExecution indicates an expected call of DescribeActivityExecution.
+func (mr *MockWorkflowServiceClientMockRecorder) DescribeActivityExecution(ctx, in any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).DescribeActivityExecution), varargs...)
+}
+
 // DescribeBatchOperation mocks base method.
 func (m *MockWorkflowServiceClient) DescribeBatchOperation(ctx context.Context, in *workflowservice.DescribeBatchOperationRequest, opts ...grpc.CallOption) (*workflowservice.DescribeBatchOperationResponse, error) {
 	m.ctrl.T.Helper()
@@ -502,6 +522,26 @@ func (mr *MockWorkflowServiceClientMockRecorder) FetchWorkerConfig(ctx, in any,
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchWorkerConfig", reflect.TypeOf((*MockWorkflowServiceClient)(nil).FetchWorkerConfig), varargs...)
 }
 
+// GetActivityExecutionOutcome mocks base method.
+func (m *MockWorkflowServiceClient) GetActivityExecutionOutcome(ctx context.Context, in *workflowservice.GetActivityExecutionOutcomeRequest, opts ...grpc.CallOption) (*workflowservice.GetActivityExecutionOutcomeResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, in}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetActivityExecutionOutcome", varargs...)
+	ret0, _ := ret[0].(*workflowservice.GetActivityExecutionOutcomeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetActivityExecutionOutcome indicates an expected call of GetActivityExecutionOutcome.
+func (mr *MockWorkflowServiceClientMockRecorder) GetActivityExecutionOutcome(ctx, in any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, in}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActivityExecutionOutcome", reflect.TypeOf((*MockWorkflowServiceClient)(nil).GetActivityExecutionOutcome), varargs...)
+}
+
 // GetClusterInfo mocks base method.
 func (m *MockWorkflowServiceClient) GetClusterInfo(ctx context.Context, in *workflowservice.GetClusterInfoRequest, opts ...grpc.CallOption) (*workflowservice.GetClusterInfoResponse, error) {
 	m.ctrl.T.Helper()
@@ -1022,26 +1062,6 @@ func (mr *MockWorkflowServiceClientMockRecorder) PauseActivity(ctx, in any, opts
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseActivity", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PauseActivity), varargs...)
 }
 
-// PauseActivityExecution mocks base method.
-func (m *MockWorkflowServiceClient) PauseActivityExecution(ctx context.Context, in *workflowservice.PauseActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.PauseActivityExecutionResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []any{ctx, in}
-	for _, a := range opts {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PauseActivityExecution", varargs...)
-	ret0, _ := ret[0].(*workflowservice.PauseActivityExecutionResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PauseActivityExecution indicates an expected call of PauseActivityExecution.
-func (mr *MockWorkflowServiceClientMockRecorder) PauseActivityExecution(ctx, in any, opts ...any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, in}, opts...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PauseActivityExecution), varargs...)
-}
-
 // PauseWorkflowExecution mocks base method.
 func (m *MockWorkflowServiceClient) PauseWorkflowExecution(ctx context.Context, in *workflowservice.PauseWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.PauseWorkflowExecutionResponse, error) {
 	m.ctrl.T.Helper()
@@ -1062,26 +1082,6 @@ func (mr *MockWorkflowServiceClientMockRecorder) PauseWorkflowExecution(ctx, in
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PauseWorkflowExecution), varargs...)
 }
 
-// PollActivityExecution mocks base method.
-func (m *MockWorkflowServiceClient) PollActivityExecution(ctx context.Context, in *workflowservice.PollActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.PollActivityExecutionResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []any{ctx, in}
-	for _, a := range opts {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PollActivityExecution", varargs...)
-	ret0, _ := ret[0].(*workflowservice.PollActivityExecutionResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// PollActivityExecution indicates an expected call of PollActivityExecution.
-func (mr *MockWorkflowServiceClientMockRecorder) PollActivityExecution(ctx, in any, opts ...any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, in}, opts...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PollActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).PollActivityExecution), varargs...)
-}
-
 // PollActivityTaskQueue mocks base method.
 func (m *MockWorkflowServiceClient) PollActivityTaskQueue(ctx context.Context, in *workflowservice.PollActivityTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.PollActivityTaskQueueResponse, error) {
 	m.ctrl.T.Helper()
@@ -1322,26 +1322,6 @@ func (mr *MockWorkflowServiceClientMockRecorder) ResetActivity(ctx, in any, opts
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetActivity", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ResetActivity), varargs...)
 }
 
-// ResetActivityExecution mocks base method.
-func (m *MockWorkflowServiceClient) ResetActivityExecution(ctx context.Context, in *workflowservice.ResetActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.ResetActivityExecutionResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []any{ctx, in}
-	for _, a := range opts {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ResetActivityExecution", varargs...)
-	ret0, _ := ret[0].(*workflowservice.ResetActivityExecutionResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// ResetActivityExecution indicates an expected call of ResetActivityExecution.
-func (mr *MockWorkflowServiceClientMockRecorder) ResetActivityExecution(ctx, in any, opts ...any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, in}, opts...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).ResetActivityExecution), varargs...)
-}
-
 // ResetStickyTaskQueue mocks base method.
 func (m *MockWorkflowServiceClient) ResetStickyTaskQueue(ctx context.Context, in *workflowservice.ResetStickyTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.ResetStickyTaskQueueResponse, error) {
 	m.ctrl.T.Helper()
@@ -1922,26 +1902,6 @@ func (mr *MockWorkflowServiceClientMockRecorder) UnpauseActivity(ctx, in any, op
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseActivity", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UnpauseActivity), varargs...)
 }
 
-// UnpauseActivityExecution mocks base method.
-func (m *MockWorkflowServiceClient) UnpauseActivityExecution(ctx context.Context, in *workflowservice.UnpauseActivityExecutionRequest, opts ...grpc.CallOption) (*workflowservice.UnpauseActivityExecutionResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []any{ctx, in}
-	for _, a := range opts {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UnpauseActivityExecution", varargs...)
-	ret0, _ := ret[0].(*workflowservice.UnpauseActivityExecutionResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UnpauseActivityExecution indicates an expected call of UnpauseActivityExecution.
-func (mr *MockWorkflowServiceClientMockRecorder) UnpauseActivityExecution(ctx, in any, opts ...any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, in}, opts...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseActivityExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UnpauseActivityExecution), varargs...)
-}
-
 // UnpauseWorkflowExecution mocks base method.
 func (m *MockWorkflowServiceClient) UnpauseWorkflowExecution(ctx context.Context, in *workflowservice.UnpauseWorkflowExecutionRequest, opts ...grpc.CallOption) (*workflowservice.UnpauseWorkflowExecutionResponse, error) {
 	m.ctrl.T.Helper()
@@ -1962,26 +1922,6 @@ func (mr *MockWorkflowServiceClientMockRecorder) UnpauseWorkflowExecution(ctx, i
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnpauseWorkflowExecution", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UnpauseWorkflowExecution), varargs...)
 }
 
-// UpdateActivityExecutionOptions mocks base method.
-func (m *MockWorkflowServiceClient) UpdateActivityExecutionOptions(ctx context.Context, in *workflowservice.UpdateActivityExecutionOptionsRequest, opts ...grpc.CallOption) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) {
-	m.ctrl.T.Helper()
-	varargs := []any{ctx, in}
-	for _, a := range opts {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "UpdateActivityExecutionOptions", varargs...)
-	ret0, _ := ret[0].(*workflowservice.UpdateActivityExecutionOptionsResponse)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// UpdateActivityExecutionOptions indicates an expected call of UpdateActivityExecutionOptions.
-func (mr *MockWorkflowServiceClientMockRecorder) UpdateActivityExecutionOptions(ctx, in any, opts ...any) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, in}, opts...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateActivityExecutionOptions", reflect.TypeOf((*MockWorkflowServiceClient)(nil).UpdateActivityExecutionOptions), varargs...)
-}
-
 // UpdateActivityOptions mocks base method.
 func (m *MockWorkflowServiceClient) UpdateActivityOptions(ctx context.Context, in *workflowservice.UpdateActivityOptionsRequest, opts ...grpc.CallOption) (*workflowservice.UpdateActivityOptionsResponse, error) {
 	m.ctrl.T.Helper()
diff --git a/go.mod b/go.mod
index d0e11cec83..9fd153fb95 100644
--- a/go.mod
+++ b/go.mod
@@ -58,7 +58,7 @@ require (
 	go.opentelemetry.io/otel/sdk v1.34.0
 	go.opentelemetry.io/otel/sdk/metric v1.34.0
 	go.opentelemetry.io/otel/trace v1.34.0
-	go.temporal.io/api v1.59.1-0.20251205162444-56515e7a50a9
+	go.temporal.io/api v1.59.1-0.20251208220711-4883d38b6ada
 	go.temporal.io/sdk v1.35.0
 	go.uber.org/fx v1.24.0
 	go.uber.org/mock v0.6.0
diff --git a/go.sum b/go.sum
index 6e1684b9bc..47d97c7647 100644
--- a/go.sum
+++ b/go.sum
@@ -390,8 +390,8 @@ go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC
 go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
 go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU/3i4=
 go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
-go.temporal.io/api v1.59.1-0.20251205162444-56515e7a50a9 h1:LDjwcdjGXOWz1SN7OwnGDn6rmYPAkNQ/uZe/U1pxkZs=
-go.temporal.io/api v1.59.1-0.20251205162444-56515e7a50a9/go.mod h1:iaxoP/9OXMJcQkETTECfwYq4cw/bj4nwov8b3ZLVnXM=
+go.temporal.io/api v1.59.1-0.20251208220711-4883d38b6ada h1:VxxoGurxPgDW8dja4SyDz+Tq+2F8XMyUS5VYaE3PWF8=
+go.temporal.io/api v1.59.1-0.20251208220711-4883d38b6ada/go.mod h1:iaxoP/9OXMJcQkETTECfwYq4cw/bj4nwov8b3ZLVnXM=
 go.temporal.io/sdk v1.35.0 h1:lRNAQ5As9rLgYa7HBvnmKyzxLcdElTuoFJ0FXM/AsLQ=
 go.temporal.io/sdk v1.35.0/go.mod h1:1q5MuLc2MEJ4lneZTHJzpVebW2oZnyxoIOWX3oFVebw=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
diff --git a/service/frontend/configs/quotas.go b/service/frontend/configs/quotas.go
index 4b806e1106..085f395d20 100644
--- a/service/frontend/configs/quotas.go
+++ b/service/frontend/configs/quotas.go
@@ -24,6 +24,8 @@ const (
 	CompleteNexusOperation                          = "/temporal.api.nexusservice.v1.NexusService/CompleteNexusOperation"
 	// PollWorkflowHistoryAPIName is used instead of GetWorkflowExecutionHistory if WaitNewEvent is true in request.
 	PollWorkflowHistoryAPIName = "/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowExecutionHistory"
+	// PollActivityExecutionAPIName is used instead of DescribeActivityExecution if LongPollToken is set in request.
+	PollActivityExecutionAPIName = "/temporal.api.workflowservice.v1.WorkflowService/PollActivityExecutionDescription"
 )
 
 var (
@@ -31,25 +33,25 @@ var (
 	// from their corresponding quota, which is determined by
 	// dynamicconfig.FrontendMaxConcurrentLongRunningRequestsPerInstance. If the value is not set,
 	// then the method is not considered a long-running request and the number of concurrent
-	// requests will not be throttled. PollActivityTaskQueue and PollWorkflowTaskQueue are
-	// long-running because they block until there is a task available. PollWorkflowExecutionUpdate
-	// is long-running because it waits for an update lifecycle stage. GetWorkflowExecutionHistory
-	// is long-running when the request is configured to perform a long-poll (WaitNewEvent is true).
-	// PollActivityExecution is long-running when the request is configured to perform a long-poll
-	// (wait_policy present). The QueryWorkflow and UpdateWorkflowExecution methods are long-running
-	// because they both block until a background WFT is complete.
+	// requests will not be throttled. The Poll* methods here are long-running because they block
+	// until there is a task available. GetWorkflowExecutionHistory and DescribeActivityExecution
+	// methods are blocking only if WaitNewEvent/LongPollToken are set, otherwise they are not
+	// long-running. The QueryWorkflow and UpdateWorkflowExecution methods are long-running because
+	// they both block until a background WFT is complete.
 	ExecutionAPICountLimitOverride = map[string]int{
 		"/temporal.api.workflowservice.v1.WorkflowService/PollActivityTaskQueue":       1,
 		"/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowTaskQueue":       1,
 		"/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowExecutionUpdate": 1,
-		// TODO: categorize appropriately as long-poll if wait_policy is present, similar to what is
-		// done with PollWorkflowHistoryAPIName below.
-		"/temporal.api.workflowservice.v1.WorkflowService/PollActivityExecution":       1,
 		"/temporal.api.workflowservice.v1.WorkflowService/QueryWorkflow":               1,
 		"/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecution":     1,
-		"/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistory": 1,
 		"/temporal.api.workflowservice.v1.WorkflowService/PollNexusTaskQueue":          1,
 
+		// Long-running if activity outcome is not already available
+		"/temporal.api.workflowservice.v1.WorkflowService/GetActivityExecutionOutcome": 1,
+		// Long-running if certain request parameters are set
+		"/temporal.api.workflowservice.v1.WorkflowService/GetWorkflowExecutionHistory": 1,
+		"/temporal.api.workflowservice.v1.WorkflowService/DescribeActivityExecution":   1,
+
 		// potentially long-running, depending on the operations
 		"/temporal.api.workflowservice.v1.WorkflowService/ExecuteMultiOperation": 1,
 
@@ -104,14 +106,9 @@ var (
 		"/temporal.api.workflowservice.v1.WorkflowService/DeleteSchedule":                        2,
 		"/temporal.api.workflowservice.v1.WorkflowService/StopBatchOperation":                    2,
 		"/temporal.api.workflowservice.v1.WorkflowService/UpdateActivityOptions":                 2,
-		"/temporal.api.workflowservice.v1.WorkflowService/UpdateActivityExecutionOptions":        2,
 		"/temporal.api.workflowservice.v1.WorkflowService/PauseActivity":                         2,
-		"/temporal.api.workflowservice.v1.WorkflowService/PauseActivityExecution":                2,
 		"/temporal.api.workflowservice.v1.WorkflowService/UnpauseActivity":                       2,
-		"/temporal.api.workflowservice.v1.WorkflowService/UnpauseActivityExecution":              2,
 		"/temporal.api.workflowservice.v1.WorkflowService/ResetActivity":                         2,
-		"/temporal.api.workflowservice.v1.WorkflowService/ResetActivityExecution":                2,
-		"/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkflowExecutionOptions":        2,
 		"/temporal.api.workflowservice.v1.WorkflowService/SetCurrentDeployment":                  2, // [cleanup-wv-pre-release]
 		"/temporal.api.workflowservice.v1.WorkflowService/SetCurrentDeploymentVersion":           2, // [cleanup-wv-pre-release]
 		"/temporal.api.workflowservice.v1.WorkflowService/SetWorkerDeploymentCurrentVersion":     2,
@@ -134,6 +131,7 @@ var (
 
 		// P3: Status Querying APIs
 		"/temporal.api.workflowservice.v1.WorkflowService/DescribeWorkflowExecution":       3,
+		"/temporal.api.workflowservice.v1.WorkflowService/DescribeActivityExecution":       3,
 		"/temporal.api.workflowservice.v1.WorkflowService/DescribeTaskQueue":               3,
 		"/temporal.api.workflowservice.v1.WorkflowService/GetWorkerBuildIdCompatibility":   3,
 		"/temporal.api.workflowservice.v1.WorkflowService/GetWorkerVersioningRules":        3,
@@ -158,9 +156,9 @@ var (
 		"/temporal.api.workflowservice.v1.WorkflowService/RespondNexusTaskFailed":          3,
 
 		// P4: Poll APIs and other low priority APIs
+		"/temporal.api.workflowservice.v1.WorkflowService/GetActivityExecutionOutcome":        4, // TODO(dan): should it be 4 or 3?
 		"/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowTaskQueue":              4,
 		"/temporal.api.workflowservice.v1.WorkflowService/PollActivityTaskQueue":              4,
-		"/temporal.api.workflowservice.v1.WorkflowService/PollActivityExecution":              4,
 		"/temporal.api.workflowservice.v1.WorkflowService/PollWorkflowExecutionUpdate":        4,
 		"/temporal.api.workflowservice.v1.WorkflowService/PollNexusTaskQueue":                 4,
 		"/temporal.api.workflowservice.v1.WorkflowService/ResetStickyTaskQueue":               4,
@@ -170,9 +168,12 @@ var (
 		"/temporal.api.workflowservice.v1.WorkflowService/FetchWorkerConfig":                  4,
 		"/temporal.api.workflowservice.v1.WorkflowService/UpdateWorkerConfig":                 4,
 
-		// P5: GetWorkflowExecutionHistory with WaitNewEvent set to true is a long poll API.
-		// Treat as long-poll but lower priority (5) so spikes don’t block Poll* APIs.
-		PollWorkflowHistoryAPIName: 5,
+		// P5: Low priority APIs
+		// GetWorkflowExecutionHistory with WaitNewEvent set to true is a long poll API.
+		// Similarly, DescribeActivityExecution is a long poll API if LongPollToken is set.
+		// Treat these as long-poll but lower priority (5) so spikes don’t block Poll* APIs.
+		PollWorkflowHistoryAPIName:   5,
+		PollActivityExecutionAPIName: 5,
 		// Informational API that aren't required for the temporal service to function
 		OpenAPIV3APIName: 5,
 		OpenAPIV2APIName: 5,
diff --git a/service/frontend/workflow_handler.go b/service/frontend/workflow_handler.go
index 877e775fa5..1b990cc9e5 100644
--- a/service/frontend/workflow_handler.go
+++ b/service/frontend/workflow_handler.go
@@ -6459,38 +6459,6 @@ func (wh *WorkflowHandler) TriggerWorkflowRule(context.Context, *workflowservice
 	return nil, serviceerror.NewUnimplemented("method TriggerWorkflowRule not supported")
 }
 
-// PauseActivityExecution pauses a standalone activity execution
-func (wh *WorkflowHandler) PauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.PauseActivityExecutionRequest,
-) (*workflowservice.PauseActivityExecutionResponse, error) {
-	return nil, serviceerror.NewUnimplemented("temporary stub during Standalone Activity prototyping")
-}
-
-// UnpauseActivityExecution unpauses a standalone activity execution
-func (wh *WorkflowHandler) UnpauseActivityExecution(
-	ctx context.Context,
-	request *workflowservice.UnpauseActivityExecutionRequest,
-) (*workflowservice.UnpauseActivityExecutionResponse, error) {
-	return nil, serviceerror.NewUnimplemented("temporary stub during Standalone Activity prototyping")
-}
-
-// ResetActivityExecution resets a standalone activity execution
-func (wh *WorkflowHandler) ResetActivityExecution(
-	ctx context.Context,
-	request *workflowservice.ResetActivityExecutionRequest,
-) (*workflowservice.ResetActivityExecutionResponse, error) {
-	return nil, serviceerror.NewUnimplemented("temporary stub during Standalone Activity prototyping")
-}
-
-// UpdateActivityExecutionOptions updates options for a standalone activity execution
-func (wh *WorkflowHandler) UpdateActivityExecutionOptions(
-	ctx context.Context,
-	request *workflowservice.UpdateActivityExecutionOptionsRequest,
-) (*workflowservice.UpdateActivityExecutionOptionsResponse, error) {
-	return nil, serviceerror.NewUnimplemented("temporary stub during Standalone Activity prototyping")
-}
-
 // PauseWorkflowExecution pauses a workflow execution.
 func (wh *WorkflowHandler) PauseWorkflowExecution(ctx context.Context, request *workflowservice.PauseWorkflowExecutionRequest) (_ *workflowservice.PauseWorkflowExecutionResponse, retError error) {
 	defer log.CapturePanic(wh.logger, &retError)
diff --git a/service/history/chasm_engine_test.go b/service/history/chasm_engine_test.go
index c6c7603a4d..a6fcb25c04 100644
--- a/service/history/chasm_engine_test.go
+++ b/service/history/chasm_engine_test.go
@@ -797,7 +797,7 @@ func (s *chasmEngineSuite) TestPollComponent_StaleState() {
 	}
 
 	testComponentTypeID, ok := s.mockShard.ChasmRegistry().ComponentIDFor(&testComponent{})
-	s.Require().True(ok)
+	s.True(ok)
 
 	s.mockExecutionManager.EXPECT().GetWorkflowExecution(gomock.Any(), gomock.Any()).
 		Return(&persistence.GetWorkflowExecutionResponse{
diff --git a/tests/standalone_activity_test.go b/tests/standalone_activity_test.go
index 240c837c0b..501d3922ec 100644
--- a/tests/standalone_activity_test.go
+++ b/tests/standalone_activity_test.go
@@ -72,7 +72,6 @@ func (s *standaloneActivityTestSuite) TestIDReusePolicy_RejectDuplicate() {
 
 	startResp := s.startAndValidateActivity(ctx, t, activityID, taskQueue)
 	runID := startResp.RunId
-
 	pollTaskResp := s.pollActivityTaskAndValidate(ctx, t, activityID, taskQueue, runID)
 
 	_, err := s.FrontendClient().RespondActivityTaskCompleted(ctx, &workflowservice.RespondActivityTaskCompletedRequest{
@@ -91,13 +90,11 @@ func (s *standaloneActivityTestSuite) TestIDReusePolicy_RejectDuplicate() {
 		ActivityType: s.tv.ActivityType(),
 		Identity:     s.tv.WorkerIdentity(),
 		Input:        defaultInput,
-		Options: &activitypb.ActivityOptions{
-			TaskQueue: &taskqueuepb.TaskQueue{
-				Name: taskQueue,
-			},
-			StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		TaskQueue: &taskqueuepb.TaskQueue{
+			Name: taskQueue,
 		},
-		IdReusePolicy: enumspb.ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE,
+		StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		IdReusePolicy:       enumspb.ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE,
 	})
 	require.Error(t, err)
 }
@@ -131,13 +128,11 @@ func (s *standaloneActivityTestSuite) TestIDReusePolicy_AllowDuplicateFailedOnly
 		ActivityType: s.tv.ActivityType(),
 		Identity:     s.tv.WorkerIdentity(),
 		Input:        defaultInput,
-		Options: &activitypb.ActivityOptions{
-			TaskQueue: &taskqueuepb.TaskQueue{
-				Name: taskQueue,
-			},
-			StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		TaskQueue: &taskqueuepb.TaskQueue{
+			Name: taskQueue,
 		},
-		IdReusePolicy: enumspb.ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY,
+		StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		IdReusePolicy:       enumspb.ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY,
 	})
 	require.NoError(t, err)
 }
@@ -159,12 +154,10 @@ func (s *standaloneActivityTestSuite) TestIDConflictPolicy_FailsIfExists() {
 		ActivityType: s.tv.ActivityType(),
 		Identity:     s.tv.WorkerIdentity(),
 		Input:        defaultInput,
-		Options: &activitypb.ActivityOptions{
-			TaskQueue: &taskqueuepb.TaskQueue{
-				Name: taskQueue,
-			},
-			StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		TaskQueue: &taskqueuepb.TaskQueue{
+			Name: taskQueue,
 		},
+		StartToCloseTimeout: durationpb.New(1 * time.Minute),
 	})
 	require.Error(t, err)
 }
@@ -333,11 +326,10 @@ func (s *standaloneActivityTestSuite) TestActivityCancelled() {
 	})
 	require.NoError(t, err)
 
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -347,7 +339,7 @@ func (s *standaloneActivityTestSuite) TestActivityCancelled() {
 	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_CANCELED, info.GetStatus(),
 		"expected Canceled but is %s", info.GetStatus())
 	require.Equal(t, "Test Cancellation", info.GetCanceledReason())
-	protorequire.ProtoEqual(t, details, activityResp.GetFailure().GetCanceledFailureInfo().GetDetails())
+	protorequire.ProtoEqual(t, details, activityResp.GetOutcome().GetFailure().GetCanceledFailureInfo().GetDetails())
 }
 
 func (s *standaloneActivityTestSuite) TestActivityCancelledByID() {
@@ -390,11 +382,10 @@ func (s *standaloneActivityTestSuite) TestActivityCancelledByID() {
 	})
 	require.NoError(t, err)
 
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -404,7 +395,7 @@ func (s *standaloneActivityTestSuite) TestActivityCancelledByID() {
 	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_CANCELED, info.GetStatus(),
 		"expected Canceled but is %s", info.GetStatus())
 	require.Equal(t, "Test Cancellation", info.GetCanceledReason())
-	protorequire.ProtoEqual(t, details, activityResp.GetFailure().GetCanceledFailureInfo().GetDetails())
+	protorequire.ProtoEqual(t, details, activityResp.GetOutcome().GetFailure().GetCanceledFailureInfo().GetDetails())
 }
 
 func (s *standaloneActivityTestSuite) TestActivityCancelled_FailsIfNeverRequested() {
@@ -461,13 +452,12 @@ func (s *standaloneActivityTestSuite) TestActivityCancelled_DuplicateRequestIDSu
 		require.NoError(t, err)
 	}
 
-	// TODO: we should get the cancel request from heart beat once we implement it
+	// TODO: we should get the cancel request from heartbeat once we implement it
 
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -592,11 +582,10 @@ func (s *standaloneActivityTestSuite) TestActivityFinishes_AfterCancelRequested(
 			err = tc.taskCompletionFn(ctx, t, pollTaskResp.GetTaskToken(), activityID, runID)
 			require.NoError(t, err)
 
-			activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-				Namespace:   s.Namespace().String(),
-				ActivityId:  activityID,
-				RunId:       runID,
-				IncludeInfo: true,
+			activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+				Namespace:  s.Namespace().String(),
+				ActivityId: activityID,
+				RunId:      runID,
 			})
 			require.NoError(t, err)
 
@@ -670,11 +659,10 @@ func (s *standaloneActivityTestSuite) TestActivityImmediatelyCancelled_WhenInSch
 		})
 		require.NoError(t, err)
 
-		activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+		activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 			Namespace:      s.Namespace().String(),
 			ActivityId:     activityID,
 			RunId:          runID,
-			IncludeInfo:    true,
 			IncludeInput:   true,
 			IncludeOutcome: true,
 		})
@@ -706,11 +694,10 @@ func (s *standaloneActivityTestSuite) TestActivityTerminated() {
 	})
 	require.NoError(t, err)
 
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -732,7 +719,7 @@ func (s *standaloneActivityTestSuite) TestActivityTerminated() {
 		Message:     "Test Termination",
 		FailureInfo: &failurepb.Failure_TerminatedFailureInfo{},
 	}
-	protorequire.ProtoEqual(t, expectedFailure, activityResp.GetFailure())
+	protorequire.ProtoEqual(t, expectedFailure, activityResp.GetOutcome().GetFailure())
 }
 
 func (s *standaloneActivityTestSuite) TestCompletedActivity_CannotTerminate() {
@@ -776,16 +763,14 @@ func (s *standaloneActivityTestSuite) TestRetryWithoutScheduleToCloseTimeout() {
 
 	// Start activity without ScheduleToCloseTimeout
 	_, err := s.FrontendClient().StartActivityExecution(ctx, &workflowservice.StartActivityExecutionRequest{
-		Namespace:    s.Namespace().String(),
-		ActivityId:   activityID,
-		ActivityType: &commonpb.ActivityType{Name: "test-activity-type"},
-		Options: &activitypb.ActivityOptions{
-			TaskQueue:           &taskqueuepb.TaskQueue{Name: taskQueue},
-			StartToCloseTimeout: durationpb.New(1 * time.Minute),
-			RetryPolicy: &commonpb.RetryPolicy{
-				InitialInterval: durationpb.New(1 * time.Millisecond),
-				MaximumAttempts: 2,
-			},
+		Namespace:           s.Namespace().String(),
+		ActivityId:          activityID,
+		ActivityType:        &commonpb.ActivityType{Name: "test-activity-type"},
+		TaskQueue:           &taskqueuepb.TaskQueue{Name: taskQueue},
+		StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		RetryPolicy: &commonpb.RetryPolicy{
+			InitialInterval: durationpb.New(1 * time.Millisecond),
+			MaximumAttempts: 2,
 		},
 	})
 	require.NoError(t, err)
@@ -832,16 +817,14 @@ func (s *standaloneActivityTestSuite) Test_ScheduleToCloseTimeout_WithRetry() {
 		ActivityType: &commonpb.ActivityType{
 			Name: "test-activity-type",
 		},
-		Options: &activitypb.ActivityOptions{
-			TaskQueue: &taskqueuepb.TaskQueue{
-				Name: taskQueue,
-			},
-			// It's not possible to guarantee (e.g. via NextRetryDelay or RetryPolicy) that a retry
-			// will start with a delay <1s because of the use of TimerProcessorMaxTimeShift in the
-			// timer queue. Therefore we allow 1s for the ActivityDispatchTask to be executed, and
-			// time out the activity 1s into Attempt 2.
-			ScheduleToCloseTimeout: durationpb.New(2 * time.Second),
+		TaskQueue: &taskqueuepb.TaskQueue{
+			Name: taskQueue,
 		},
+		// It's not possible to guarantee (e.g. via NextRetryDelay or RetryPolicy) that a retry
+		// will start with a delay <1s because of the use of TimerProcessorMaxTimeShift in the
+		// timer queue. Therefore we allow 1s for the ActivityDispatchTask to be executed, and
+		// time out the activity 1s into Attempt 2.
+		ScheduleToCloseTimeout: durationpb.New(2 * time.Second),
 	})
 	require.NoError(t, err)
 
@@ -864,26 +847,19 @@ func (s *standaloneActivityTestSuite) Test_ScheduleToCloseTimeout_WithRetry() {
 	require.NoError(t, err)
 
 	// Wait for schedule-to-close timeout.
-	pollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-		Namespace:      s.Namespace().String(),
-		ActivityId:     activityID,
-		RunId:          startResp.RunId,
-		IncludeInfo:    true,
-		IncludeOutcome: true,
-		WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitCompletion{
-			WaitCompletion: &workflowservice.PollActivityExecutionRequest_CompletionWaitOptions{},
-		},
+	getOutcomeResp, err := s.FrontendClient().GetActivityExecutionOutcome(ctx, &workflowservice.GetActivityExecutionOutcomeRequest{
+		Namespace:  s.Namespace().String(),
+		ActivityId: activityID,
+		RunId:      startResp.RunId,
 	})
 	require.NoError(t, err)
-	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_TIMED_OUT, pollResp.GetInfo().GetStatus(),
-		"expected TimedOut but is %s", pollResp.GetInfo().GetStatus())
-	require.Equal(t, enumspb.TIMEOUT_TYPE_SCHEDULE_TO_CLOSE, pollResp.GetFailure().GetTimeoutFailureInfo().GetTimeoutType(),
-		"expected ScheduleToCloseTimeout but is %s", pollResp.GetFailure().GetTimeoutFailureInfo().GetTimeoutType())
+	require.Equal(t, enumspb.TIMEOUT_TYPE_SCHEDULE_TO_CLOSE, getOutcomeResp.GetOutcome().GetFailure().GetTimeoutFailureInfo().GetTimeoutType(),
+		"expected ScheduleToCloseTimeout but is %s", getOutcomeResp.GetOutcome().GetFailure().GetTimeoutFailureInfo().GetTimeoutType())
 }
 
 // TestStartToCloseTimeout tests that a start-to-close timeout is recorded after the activity is
-// started. It also verifies that PollActivityExecution can be used to poll for a TimedOut state
-// change caused by execution of a timer task.
+// started. It also verifies that DescribeActivityExecution can be used to long-poll for a TimedOut
+// state change caused by execution of a timer task.
 func (s *standaloneActivityTestSuite) TestStartToCloseTimeout() {
 	t := s.T()
 
@@ -900,33 +876,31 @@ func (s *standaloneActivityTestSuite) TestStartToCloseTimeout() {
 			Name: "test-activity-type",
 		},
 		Input: payloads.EncodeString("test-activity-input"),
-		Options: &activitypb.ActivityOptions{
-			TaskQueue: &taskqueuepb.TaskQueue{
-				Name: taskQueue.Name,
-			},
-			StartToCloseTimeout: durationpb.New(1 * time.Second),
-			RetryPolicy: &commonpb.RetryPolicy{
-				MaximumAttempts: 1,
-			},
+		TaskQueue: &taskqueuepb.TaskQueue{
+			Name: taskQueue.Name,
+		},
+		StartToCloseTimeout: durationpb.New(1 * time.Second),
+		// This test is expecting activity failure on start-to-close timeout.
+		RetryPolicy: &commonpb.RetryPolicy{
+			MaximumAttempts: 1,
 		},
 		RequestId: "test-request-id",
 	})
 	require.NoError(t, err)
 
 	// First poll: activity has not started yet
-	pollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-		Namespace:   s.Namespace().String(),
-		ActivityId:  activityID,
-		RunId:       startResp.RunId,
-		IncludeInfo: true,
+	describeResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+		Namespace:  s.Namespace().String(),
+		ActivityId: activityID,
+		RunId:      startResp.RunId,
 	})
 	require.NoError(t, err)
-	require.NotNil(t, pollResp)
-	require.NotNil(t, pollResp.GetInfo())
-	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING, pollResp.GetInfo().GetStatus(),
-		"expected Running but is %s", pollResp.GetInfo().GetStatus())
-	require.Equal(t, enumspb.PENDING_ACTIVITY_STATE_SCHEDULED, pollResp.GetInfo().GetRunState(),
-		"expected Scheduled but is %s", pollResp.GetInfo().GetRunState())
+	require.NotNil(t, describeResp)
+	require.NotNil(t, describeResp.GetInfo())
+	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING, describeResp.GetInfo().GetStatus(),
+		"expected Running but is %s", describeResp.GetInfo().GetStatus())
+	require.Equal(t, enumspb.PENDING_ACTIVITY_STATE_SCHEDULED, describeResp.GetInfo().GetRunState(),
+		"expected Scheduled but is %s", describeResp.GetInfo().GetRunState())
 
 	// Worker poll to start the activity
 	pollTaskResp, err := s.FrontendClient().PollActivityTaskQueue(ctx, &workflowservice.PollActivityTaskQueueRequest{
@@ -941,61 +915,51 @@ func (s *standaloneActivityTestSuite) TestStartToCloseTimeout() {
 	require.NotEmpty(t, pollTaskResp.TaskToken)
 
 	// Second poll: activity has started
-	pollResp, err = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-		Namespace:   s.Namespace().String(),
-		ActivityId:  activityID,
-		RunId:       startResp.RunId,
-		IncludeInfo: true,
-		WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-			WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-				LongPollToken: pollResp.StateChangeLongPollToken,
-			},
-		},
+	describeResp, err = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+		Namespace:     s.Namespace().String(),
+		ActivityId:    activityID,
+		RunId:         startResp.RunId,
+		LongPollToken: describeResp.LongPollToken,
 	})
 	require.NoError(t, err)
-	require.NotNil(t, pollResp)
-	require.NotNil(t, pollResp.GetInfo())
-	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING, pollResp.GetInfo().GetStatus(),
-		"expected Running but is %s", pollResp.GetInfo().GetStatus())
-	require.Equal(t, enumspb.PENDING_ACTIVITY_STATE_STARTED, pollResp.GetInfo().GetRunState(),
-		"expected Started but is %s", pollResp.GetInfo().GetRunState())
+	require.NotNil(t, describeResp)
+	require.NotNil(t, describeResp.GetInfo())
+	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING, describeResp.GetInfo().GetStatus(),
+		"expected Running but is %s", describeResp.GetInfo().GetStatus())
+	require.Equal(t, enumspb.PENDING_ACTIVITY_STATE_STARTED, describeResp.GetInfo().GetRunState(),
+		"expected Started but is %s", describeResp.GetInfo().GetRunState())
 
 	// Third poll: activity has timed out
-	pollResp, err = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	describeResp, err = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          startResp.RunId,
-		IncludeInfo:    true,
 		IncludeOutcome: true,
-		WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-			WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-				LongPollToken: pollResp.StateChangeLongPollToken,
-			},
-		},
+		LongPollToken:  describeResp.LongPollToken,
 	})
 
 	require.NoError(t, err)
-	require.NotNil(t, pollResp)
-	require.NotNil(t, pollResp.GetInfo())
+	require.NotNil(t, describeResp)
+	require.NotNil(t, describeResp.GetInfo())
 
 	// The activity has timed out due to StartToClose. This is an attempt failure, therefore the
 	// failure should be in ActivityExecutionInfo.LastFailure as well as set as the outcome failure.
-	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_TIMED_OUT, pollResp.GetInfo().GetStatus(),
-		"expected TimedOut but is %s", pollResp.GetInfo().GetStatus())
-	failure := pollResp.GetInfo().GetLastFailure()
+	require.Equal(t, enumspb.ACTIVITY_EXECUTION_STATUS_TIMED_OUT, describeResp.GetInfo().GetStatus(),
+		"expected TimedOut but is %s", describeResp.GetInfo().GetStatus())
+	failure := describeResp.GetInfo().GetLastFailure()
 	require.NotNil(t, failure)
 	timeoutFailure := failure.GetTimeoutFailureInfo()
 	require.NotNil(t, timeoutFailure)
 	require.Equal(t, enumspb.TIMEOUT_TYPE_START_TO_CLOSE, timeoutFailure.GetTimeoutType(),
 		"expected StartToCloseTimeout but is %s", timeoutFailure.GetTimeoutType())
 
-	require.NotNil(t, pollResp.GetFailure())
-	protorequire.ProtoEqual(t, failure, pollResp.GetFailure())
-	require.Equal(t, enumspb.TIMEOUT_TYPE_START_TO_CLOSE, pollResp.GetFailure().GetTimeoutFailureInfo().GetTimeoutType(),
-		"expected StartToCloseTimeout but is %s", pollResp.GetFailure().GetTimeoutFailureInfo().GetTimeoutType())
+	require.NotNil(t, describeResp.GetOutcome().GetFailure())
+	protorequire.ProtoEqual(t, failure, describeResp.GetOutcome().GetFailure())
+	require.Equal(t, enumspb.TIMEOUT_TYPE_START_TO_CLOSE, describeResp.GetOutcome().GetFailure().GetTimeoutFailureInfo().GetTimeoutType(),
+		"expected StartToCloseTimeout but is %s", describeResp.GetOutcome().GetFailure().GetTimeoutFailureInfo().GetTimeoutType())
 }
 
-func (s *standaloneActivityTestSuite) TestPollActivityExecution_NoWait() {
+func (s *standaloneActivityTestSuite) TestDescribeActivityExecution_NoWait() {
 	t := s.T()
 	ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
 	defer cancel()
@@ -1006,52 +970,49 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NoWait() {
 	require.NoError(t, err)
 
 	t.Run("MinimalResponse", func(t *testing.T) {
-		pollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+		describeResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 			Namespace:  s.Namespace().String(),
 			ActivityId: activityID,
 			// Omit RunID to verify that latest run will be used
-			IncludeInfo:    false,
 			IncludeInput:   false,
 			IncludeOutcome: false,
 		})
 		require.NoError(t, err)
-		require.NotNil(t, pollResp.StateChangeLongPollToken)
-		require.Equal(t, startResp.RunId, pollResp.RunId)
-		require.Nil(t, pollResp.Info)
-		require.Nil(t, pollResp.Input)
-		require.Nil(t, pollResp.GetResult())
-		require.Nil(t, pollResp.GetFailure())
+		require.NotNil(t, describeResp.LongPollToken)
+		require.Equal(t, startResp.RunId, describeResp.RunId)
+		require.Nil(t, describeResp.Input)
+		require.Nil(t, describeResp.GetOutcome().GetResult())
+		require.Nil(t, describeResp.GetOutcome().GetFailure())
 	})
 
 	t.Run("FullResponse", func(t *testing.T) {
-		pollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+		describeResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 			Namespace:      s.Namespace().String(),
 			ActivityId:     activityID,
 			RunId:          startResp.RunId,
-			IncludeInfo:    true,
 			IncludeInput:   true,
 			IncludeOutcome: true,
 		})
 		require.NoError(t, err)
-		require.NotNil(t, pollResp.StateChangeLongPollToken)
-		require.NotNil(t, pollResp.Info)
+		require.NotNil(t, describeResp.LongPollToken)
+		require.NotNil(t, describeResp.Info)
 		s.assertActivityExecutionInfo(
 			t,
-			pollResp.Info,
+			describeResp.Info,
 			activityID,
 			startResp.RunId,
 			enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING,
 			enumspb.PENDING_ACTIVITY_STATE_SCHEDULED,
 		)
-		protorequire.ProtoEqual(t, defaultInput, pollResp.Input)
+		protorequire.ProtoEqual(t, defaultInput, describeResp.Input)
 
 		// Activity is scheduled but not completed, so no outcome yet
-		require.Nil(t, pollResp.GetResult())
-		require.Nil(t, pollResp.GetFailure())
+		require.Nil(t, describeResp.GetOutcome().GetResult())
+		require.Nil(t, describeResp.GetOutcome().GetFailure())
 	})
 }
 
-func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitAnyStateChange() {
+func (s *standaloneActivityTestSuite) TestDescribeActivityExecution_WaitAnyStateChange() {
 	// Long poll for any state change. PollActivityTaskQueue is used to cause a state change.
 	t := s.T()
 	ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
@@ -1063,23 +1024,19 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitAnyStateChan
 	require.NoError(t, err)
 
 	// First poll lacks token and therefore responds immediately, returning a token
-	firstPollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	firstDescribeResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:  s.Namespace().String(),
 		ActivityId: activityID,
-		RunId:      startResp.RunId, // RunID is now required by validation
-		WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-			WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{},
-		},
-		IncludeInfo:  true,
+		// RunId:        startResp.RunId, // RunID is now required by validation [?]
 		IncludeInput: true,
 	})
 	require.NoError(t, err)
-	require.NotNil(t, firstPollResp.StateChangeLongPollToken)
-	require.NotNil(t, firstPollResp.Info)
-	require.Equal(t, firstPollResp.RunId, startResp.RunId)
+	require.NotNil(t, firstDescribeResp.LongPollToken)
+	require.NotNil(t, firstDescribeResp.Info)
+	require.Equal(t, firstDescribeResp.RunId, startResp.RunId)
 	s.assertActivityExecutionInfo(
 		t,
-		firstPollResp.Info,
+		firstDescribeResp.Info,
 		activityID,
 		startResp.RunId,
 		enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING,
@@ -1088,23 +1045,18 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitAnyStateChan
 
 	taskQueuePollErr := make(chan error, 1)
 	activityPollDone := make(chan struct{})
-	var activityPollResp *workflowservice.PollActivityExecutionResponse
-	var activityPollErr error
+	var describeResp *workflowservice.DescribeActivityExecutionResponse
+	var describeErr error
 
 	go func() {
 		defer close(activityPollDone)
 		// Second poll uses token and therefore waits for a state transition
-		activityPollResp, activityPollErr = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-			Namespace:    s.Namespace().String(),
-			ActivityId:   activityID,
-			RunId:        startResp.RunId,
-			IncludeInfo:  true,
-			IncludeInput: true,
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: firstPollResp.StateChangeLongPollToken,
-				},
-			},
+		describeResp, describeErr = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+			Namespace:     s.Namespace().String(),
+			ActivityId:    activityID,
+			RunId:         startResp.RunId,
+			IncludeInput:  true,
+			LongPollToken: firstDescribeResp.LongPollToken,
 		})
 	}()
 
@@ -1118,33 +1070,33 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitAnyStateChan
 
 	select {
 	case <-activityPollDone:
-		require.NoError(t, activityPollErr)
-		require.NotNil(t, activityPollResp)
-		require.NotNil(t, activityPollResp.Info)
+		require.NoError(t, describeErr)
+		require.NotNil(t, describeResp)
+		require.NotNil(t, describeResp.Info)
 		s.assertActivityExecutionInfo(
 			t,
-			activityPollResp.Info,
+			describeResp.Info,
 			activityID,
 			startResp.RunId,
 			enumspb.ACTIVITY_EXECUTION_STATUS_RUNNING,
 			enumspb.PENDING_ACTIVITY_STATE_STARTED,
 		)
-		protorequire.ProtoEqual(t, defaultInput, activityPollResp.Input)
+		protorequire.ProtoEqual(t, defaultInput, describeResp.Input)
 
 	case <-ctx.Done():
-		t.Fatal("PollActivityExecution timed out")
+		t.Fatal("DescribeActivityExecution timed out")
 	}
 
 	err = <-taskQueuePollErr
 	require.NoError(t, err)
 }
 
-func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitCompletion() {
+func (s *standaloneActivityTestSuite) TestGetActivityExecutionOutcome() {
 	testCases := []struct {
 		name                   string
 		expectedStatus         enumspb.ActivityExecutionStatus
 		taskCompletionFn       func(context.Context, []byte) error
-		completionValidationFn func(*testing.T, *workflowservice.PollActivityExecutionResponse)
+		completionValidationFn func(*testing.T, *workflowservice.GetActivityExecutionOutcomeResponse)
 	}{
 		{
 			name:           "successful completion",
@@ -1158,8 +1110,8 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitCompletion()
 
 				return err
 			},
-			completionValidationFn: func(t *testing.T, response *workflowservice.PollActivityExecutionResponse) {
-				protorequire.ProtoEqual(t, defaultResult, response.GetResult())
+			completionValidationFn: func(t *testing.T, response *workflowservice.GetActivityExecutionOutcomeResponse) {
+				protorequire.ProtoEqual(t, defaultResult, response.GetOutcome().GetResult())
 			},
 		},
 		{
@@ -1174,9 +1126,8 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitCompletion()
 
 				return err
 			},
-			completionValidationFn: func(t *testing.T, response *workflowservice.PollActivityExecutionResponse) {
-				protorequire.ProtoEqual(t, defaultFailure, response.GetInfo().GetLastFailure())
-				protorequire.ProtoEqual(t, defaultFailure, response.GetFailure())
+			completionValidationFn: func(t *testing.T, response *workflowservice.GetActivityExecutionOutcomeResponse) {
+				protorequire.ProtoEqual(t, defaultFailure, response.GetOutcome().GetFailure())
 			},
 		},
 	}
@@ -1186,51 +1137,152 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_WaitCompletion()
 			t := s.T()
 			ctx, cancel := context.WithTimeout(t.Context(), 10*time.Second)
 			t.Cleanup(cancel)
-
 			activityID := s.tv.Any().String()
 			taskQueue := s.tv.TaskQueue().String()
 
 			startResp, err := s.startActivity(ctx, activityID, taskQueue)
 			require.NoError(t, err)
-
 			pollTaskResp, err := s.pollActivityTaskQueue(ctx, taskQueue)
 			require.NoError(t, err)
-
 			err = tc.taskCompletionFn(ctx, pollTaskResp.TaskToken)
 			require.NoError(t, err)
-
-			activityPollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-				Namespace:      s.Namespace().String(),
-				ActivityId:     activityID,
-				RunId:          startResp.RunId,
-				IncludeInfo:    true,
-				IncludeInput:   true,
-				IncludeOutcome: true,
-				WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitCompletion{
-					WaitCompletion: &workflowservice.PollActivityExecutionRequest_CompletionWaitOptions{},
-				},
+			getOutcomeResp, err := s.FrontendClient().GetActivityExecutionOutcome(ctx, &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  s.Namespace().String(),
+				ActivityId: activityID,
+				RunId:      startResp.RunId,
 			})
 			require.NoError(t, err)
-			require.NotNil(t, activityPollResp)
-			require.NotNil(t, activityPollResp.Info)
-			s.assertActivityExecutionInfo(
-				t,
-				activityPollResp.Info,
-				activityID,
-				startResp.RunId,
-				tc.expectedStatus,
-				enumspb.PENDING_ACTIVITY_STATE_UNSPECIFIED,
-			)
-
-			protorequire.ProtoEqual(t, defaultInput, activityPollResp.GetInput())
-			tc.completionValidationFn(t, activityPollResp)
+			require.NotNil(t, getOutcomeResp)
+			tc.completionValidationFn(t, getOutcomeResp)
+		})
+	}
+}
+
+func (s *standaloneActivityTestSuite) TestGetActivityExecutionOutcome_NotFound() {
+	t := s.T()
+	ctx := testcore.NewContext()
+
+	existingActivityID := s.tv.ActivityID()
+	tq := s.tv.TaskQueue()
+	startResp, err := s.startActivity(ctx, existingActivityID, tq.Name)
+	require.NoError(t, err)
+	existingRunID := startResp.RunId
+	require.NotEmpty(t, existingRunID)
+	existingNamespace := s.Namespace().String()
+
+	var notFoundErr *serviceerror.NotFound
+	var namespaceNotFoundErr *serviceerror.NamespaceNotFound
+
+	testCases := []struct {
+		name           string
+		request        *workflowservice.GetActivityExecutionOutcomeRequest
+		expectedErr    error
+		expectedErrMsg string
+	}{
+		{
+			name: "NonExistentNamespace",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  "non-existent-namespace",
+				ActivityId: existingActivityID,
+				RunId:      existingRunID,
+			},
+			expectedErr:    namespaceNotFoundErr,
+			expectedErrMsg: "Namespace non-existent-namespace is not found.",
+		},
+		{
+			name: "NonExistentActivityID",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  existingNamespace,
+				ActivityId: "non-existent-activity",
+				RunId:      existingRunID,
+			},
+			expectedErr:    notFoundErr,
+			expectedErrMsg: "activity execution not found",
+		},
+		{
+			name: "NonExistentRunID",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  existingNamespace,
+				ActivityId: existingActivityID,
+				RunId:      "11111111-2222-3333-4444-555555555555",
+			},
+			expectedErr:    notFoundErr,
+			expectedErrMsg: "activity execution not found",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := s.FrontendClient().GetActivityExecutionOutcome(ctx, tc.request)
+			require.ErrorAs(t, err, &tc.expectedErr) //nolint:testifylint
+			require.Equal(t, tc.expectedErrMsg, tc.expectedErr.Error())
+		})
+	}
+}
+
+func (s *standaloneActivityTestSuite) TestGetActivityExecutionOutcome_InvalidArgument() {
+	t := s.T()
+	ctx := testcore.NewContext()
+
+	existingNamespace := s.Namespace().String()
+	validRunID := "11111111-2222-3333-4444-555555555555"
+
+	testCases := []struct {
+		name        string
+		request     *workflowservice.GetActivityExecutionOutcomeRequest
+		expectedErr string
+	}{
+		{
+			name: "EmptyNamespace",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  "",
+				ActivityId: "activity-id",
+				RunId:      validRunID,
+			},
+			expectedErr: "Namespace is empty",
+		},
+		{
+			name: "EmptyActivityID",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  existingNamespace,
+				ActivityId: "",
+				RunId:      validRunID,
+			},
+			expectedErr: "activity ID is required",
+		},
+		{
+			name: "ActivityIDTooLong",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  existingNamespace,
+				ActivityId: string(make([]byte, 2000)),
+				RunId:      validRunID,
+			},
+			expectedErr: "activity ID exceeds length limit",
+		},
+		{
+			name: "InvalidRunID",
+			request: &workflowservice.GetActivityExecutionOutcomeRequest{
+				Namespace:  existingNamespace,
+				ActivityId: "activity-id",
+				RunId:      "invalid-uuid",
+			},
+			expectedErr: "invalid run id",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := s.FrontendClient().GetActivityExecutionOutcome(ctx, tc.request)
+			var invalidArgErr *serviceerror.InvalidArgument
+			require.ErrorAs(t, err, &invalidArgErr)
+			require.Contains(t, invalidArgErr.Message, tc.expectedErr)
 		})
 	}
 }
 
-// TODO(dan): add tests that PollActivityExecution can wait for deletion, termination, cancellation etc
+// TODO(dan): add tests that DescribeActivityExecution can wait for deletion, termination, cancellation etc
 
-func (s *standaloneActivityTestSuite) TestPollActivityExecution_DeadlineExceeded() {
+func (s *standaloneActivityTestSuite) TestDescribeActivityExecution_DeadlineExceeded() {
 	t := s.T()
 	ctx := testcore.NewContext()
 
@@ -1239,17 +1291,14 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_DeadlineExceeded
 	taskQueue := s.tv.TaskQueue()
 	startResp, err := s.startActivity(ctx, activityID, taskQueue.Name)
 	require.NoError(t, err)
-	pollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	describeResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:  s.Namespace().String(),
 		ActivityId: activityID,
 		RunId:      startResp.RunId,
-		WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-			WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{},
-		},
 	})
 	require.NoError(t, err)
 
-	// The PollActivityExecution calls below use a long-poll token and will necessarily time out,
+	// The DescribeActivityExecution calls below use a long-poll token and will necessarily time out,
 	// because the activity undergoes no further state transitions.
 
 	// The timeout imposed by the server is essentially
@@ -1263,24 +1312,19 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_DeadlineExceeded
 		ctx, cancel := context.WithTimeout(ctx, 9999*time.Millisecond)
 		defer cancel()
 
-		// PollActivityExecution will return when this long poll timeout expires.
+		// DescribeActivityExecution will return when this long poll timeout expires.
 		s.OverrideDynamicConfig(activity.LongPollTimeout, 10*time.Millisecond)
 
-		pollResp, err = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-			Namespace:   s.Namespace().String(),
-			ActivityId:  activityID,
-			RunId:       startResp.RunId,
-			IncludeInfo: true,
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: pollResp.StateChangeLongPollToken,
-				},
-			},
+		describeResp, err = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+			Namespace:     s.Namespace().String(),
+			ActivityId:    activityID,
+			RunId:         startResp.RunId,
+			LongPollToken: describeResp.LongPollToken,
 		})
 		// The server uses an empty non-error response to indicate to the caller that it should resubmit
 		// its long-poll.
 		require.NoError(t, err)
-		require.Empty(t, pollResp.GetInfo())
+		require.Empty(t, describeResp.GetInfo())
 	})
 
 	// Case 2: caller does not set a deadline. In practice this is equivalent to them setting a 30s
@@ -1292,29 +1336,25 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_DeadlineExceeded
 		// still must use a buffer < 30s.
 		ctx := context.Background()
 		s.OverrideDynamicConfig(activity.LongPollBuffer, 29*time.Second)
-		// PollActivityExecution will return when this long poll timeout expires.
+		// DescribeActivityExecution will return when this long poll timeout expires.
 		s.OverrideDynamicConfig(activity.LongPollTimeout, 10*time.Millisecond)
 
-		_, err = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-			Namespace:  s.Namespace().String(),
-			ActivityId: activityID,
-			RunId:      startResp.RunId,
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: pollResp.StateChangeLongPollToken,
-				},
-			},
+		_, err = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+			Namespace:     s.Namespace().String(),
+			ActivityId:    activityID,
+			RunId:         startResp.RunId,
+			LongPollToken: describeResp.LongPollToken,
 		})
 		require.NoError(t, err)
-		require.Empty(t, pollResp.GetInfo())
+		require.Empty(t, describeResp.GetInfo())
 	})
 
-	// Case 3: caller sets a deadline that is < the buffer. In this case PollActivityExecution will
-	// return an empty result immediately, and there is a race between caller receiving that and
-	// caller's client timing out the request. Therefore we do not test this.
+	// Case 3: caller sets a deadline that is < the buffer. In this case DescribeActivityExecution
+	// will return an empty result immediately, and there is a race between caller receiving that
+	// and caller's client timing out the request. Therefore we do not test this.
 }
 
-func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
+func (s *standaloneActivityTestSuite) TestDescribeActivityExecution_NotFound() {
 	t := s.T()
 	ctx := testcore.NewContext()
 
@@ -1331,13 +1371,13 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
 
 	testCases := []struct {
 		name           string
-		request        *workflowservice.PollActivityExecutionRequest
+		request        *workflowservice.DescribeActivityExecutionRequest
 		expectedErr    error
 		expectedErrMsg string
 	}{
 		{
 			name: "NonExistentNamespace",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  "non-existent-namespace",
 				ActivityId: existingActivityID,
 				RunId:      existingRunID,
@@ -1347,7 +1387,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
 		},
 		{
 			name: "NonExistentActivityID",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: "non-existent-activity",
 				RunId:      existingRunID,
@@ -1357,7 +1397,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
 		},
 		{
 			name: "NonExistentRunID",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: existingActivityID,
 				RunId:      "11111111-2222-3333-4444-555555555555",
@@ -1369,7 +1409,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			_, err := s.FrontendClient().PollActivityExecution(ctx, tc.request)
+			_, err := s.FrontendClient().DescribeActivityExecution(ctx, tc.request)
 			require.ErrorAs(t, err, &tc.expectedErr) //nolint:testifylint
 			require.Equal(t, tc.expectedErrMsg, tc.expectedErr.Error())
 		})
@@ -1377,28 +1417,19 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
 
 	t.Run("LongPollNonExistentActivity", func(t *testing.T) {
 		// Poll to get a token
-		validPollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+		validPollResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 			Namespace:  existingNamespace,
 			ActivityId: existingActivityID,
 			RunId:      existingRunID,
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: nil,
-				},
-			},
 		})
 		require.NoError(t, err)
 
 		// Use the token with a non-existent activity
-		_, err = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-			Namespace:  existingNamespace,
-			ActivityId: "non-existent-activity",
-			RunId:      existingRunID,
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: validPollResp.StateChangeLongPollToken,
-				},
-			},
+		_, err = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+			Namespace:     existingNamespace,
+			ActivityId:    "non-existent-activity",
+			RunId:         existingRunID,
+			LongPollToken: validPollResp.LongPollToken,
 		})
 		var notFoundErr *serviceerror.NotFound
 		require.ErrorAs(t, err, &notFoundErr)
@@ -1406,7 +1437,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_NotFound() {
 	})
 }
 
-func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument() {
+func (s *standaloneActivityTestSuite) TestDescribeActivityExecution_InvalidArgument() {
 
 	t := s.T()
 	ctx := testcore.NewContext()
@@ -1424,12 +1455,12 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 
 	testCases := []struct {
 		name        string
-		request     *workflowservice.PollActivityExecutionRequest
+		request     *workflowservice.DescribeActivityExecutionRequest
 		expectedErr string
 	}{
 		{
 			name: "EmptyNamespace",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  "",
 				ActivityId: validActivityID,
 				RunId:      validRunID,
@@ -1438,7 +1469,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 		},
 		{
 			name: "EmptyActivityID",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: "",
 				RunId:      validRunID,
@@ -1447,7 +1478,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 		},
 		{
 			name: "ActivityIDTooLong",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: string(make([]byte, 2000)),
 				RunId:      validRunID,
@@ -1456,7 +1487,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 		},
 		{
 			name: "InvalidRunID",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: validActivityID,
 				RunId:      "invalid-uuid",
@@ -1465,7 +1496,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 		},
 		{
 			name: "RunIdNotRequiredWhenWaitPolicyAbsent",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: existingActivityID,
 				RunId:      "",
@@ -1474,43 +1505,30 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 		},
 		{
 			name: "RunIdNotRequiredWhenLongPollTokenAbsent",
-			request: &workflowservice.PollActivityExecutionRequest{
+			request: &workflowservice.DescribeActivityExecutionRequest{
 				Namespace:  existingNamespace,
 				ActivityId: existingActivityID,
 				RunId:      "",
-				WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-					WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-						LongPollToken: nil,
-					},
-				},
 			},
 			expectedErr: "",
 		},
 		{
 			name: "RunIdRequiredWhenLongPollTokenPresent",
-			request: &workflowservice.PollActivityExecutionRequest{
-				Namespace:  existingNamespace,
-				ActivityId: validActivityID,
-				RunId:      "",
-				WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-					WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-						LongPollToken: []byte("valid-token"),
-					},
-				},
+			request: &workflowservice.DescribeActivityExecutionRequest{
+				Namespace:     existingNamespace,
+				ActivityId:    validActivityID,
+				RunId:         "",
+				LongPollToken: []byte("doesn't-matter"),
 			},
 			expectedErr: "run id is required",
 		},
 		{
 			name: "MalformedLongPollToken",
-			request: &workflowservice.PollActivityExecutionRequest{
-				Namespace:  existingNamespace,
-				ActivityId: existingActivityID,
-				RunId:      existingRunID,
-				WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-					WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-						LongPollToken: []byte("invalid-token"),
-					},
-				},
+			request: &workflowservice.DescribeActivityExecutionRequest{
+				Namespace:     existingNamespace,
+				ActivityId:    existingActivityID,
+				RunId:         existingRunID,
+				LongPollToken: []byte("invalid-token"),
 			},
 			expectedErr: "invalid long poll token",
 		},
@@ -1518,7 +1536,7 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			_, err := s.FrontendClient().PollActivityExecution(ctx, tc.request)
+			_, err := s.FrontendClient().DescribeActivityExecution(ctx, tc.request)
 			if tc.expectedErr == "" {
 				require.NoError(t, err)
 				return
@@ -1530,33 +1548,24 @@ func (s *standaloneActivityTestSuite) TestPollActivityExecution_InvalidArgument(
 	}
 
 	t.Run("LongPollTokenFromWrongExecution", func(t *testing.T) {
-		validPollResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+		validPollResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 			Namespace:  existingNamespace,
 			ActivityId: existingActivityID,
 			RunId:      existingRunID,
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: nil,
-				},
-			},
 		})
 		require.NoError(t, err)
-		require.NotEmpty(t, validPollResp.StateChangeLongPollToken)
+		require.NotEmpty(t, validPollResp.LongPollToken)
 
 		activityID2 := s.tv.Any().String()
 		startResp2, err := s.startActivity(ctx, activityID2, tq.Name)
 		require.NoError(t, err)
 		require.NotEmpty(t, startResp2.GetRunId())
 
-		_, err = s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
-			Namespace:  existingNamespace,
-			ActivityId: activityID2,
-			RunId:      startResp2.GetRunId(),
-			WaitPolicy: &workflowservice.PollActivityExecutionRequest_WaitAnyStateChange{
-				WaitAnyStateChange: &workflowservice.PollActivityExecutionRequest_StateChangeWaitOptions{
-					LongPollToken: validPollResp.StateChangeLongPollToken,
-				},
-			},
+		_, err = s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
+			Namespace:     existingNamespace,
+			ActivityId:    activityID2,
+			RunId:         startResp2.GetRunId(),
+			LongPollToken: validPollResp.LongPollToken,
 		})
 		var invalidArgErr *serviceerror.InvalidArgument
 		require.ErrorAs(t, err, &invalidArgErr)
@@ -1583,8 +1592,8 @@ func (s *standaloneActivityTestSuite) assertActivityExecutionInfo(
 	require.Equal(t, runState, info.RunState)
 
 	// TODO(dan): This test to be finalized when full API surface area implemented.
-	if info.ScheduledTime != nil && info.ExpirationTime != nil {
-		require.Less(t, info.ScheduledTime, info.ExpirationTime)
+	if info.ScheduleTime != nil && info.ExpirationTime != nil {
+		require.Less(t, info.ScheduleTime, info.ExpirationTime)
 	}
 	// info.Attempt
 	// info.MaximumAttempts
@@ -1623,11 +1632,10 @@ func (s *standaloneActivityTestSuite) startAndValidateActivity(
 	require.NotNil(t, startResponse.GetRunId())
 	require.True(t, startResponse.Started)
 
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          startResponse.RunId,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -1669,11 +1677,10 @@ func (s *standaloneActivityTestSuite) pollActivityTaskAndValidate(
 	protorequire.ProtoEqual(t, s.tv.ActivityType(), pollTaskResp.GetActivityType())
 	require.EqualValues(t, 1, pollTaskResp.Attempt)
 
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -1704,11 +1711,10 @@ func (s *standaloneActivityTestSuite) validateCompletion(
 	runID string,
 	workerIdentity string,
 ) {
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -1727,7 +1733,7 @@ func (s *standaloneActivityTestSuite) validateCompletion(
 	require.Nil(t, info.GetLastFailure())
 	require.Nil(t, info.GetHeartbeatDetails())
 	require.Nil(t, info.GetLastHeartbeatTime())
-	protorequire.ProtoEqual(t, defaultResult, activityResp.GetResult())
+	protorequire.ProtoEqual(t, defaultResult, activityResp.GetOutcome().GetResult())
 }
 
 func (s *standaloneActivityTestSuite) validateFailure(
@@ -1738,11 +1744,10 @@ func (s *standaloneActivityTestSuite) validateFailure(
 	expectedHeartbeatDetails *commonpb.Payloads,
 	workerIdentity string,
 ) {
-	activityResp, err := s.FrontendClient().PollActivityExecution(ctx, &workflowservice.PollActivityExecutionRequest{
+	activityResp, err := s.FrontendClient().DescribeActivityExecution(ctx, &workflowservice.DescribeActivityExecutionRequest{
 		Namespace:      s.Namespace().String(),
 		ActivityId:     activityID,
 		RunId:          runID,
-		IncludeInfo:    true,
 		IncludeInput:   true,
 		IncludeOutcome: true,
 	})
@@ -1759,7 +1764,7 @@ func (s *standaloneActivityTestSuite) validateFailure(
 	require.Equal(t, workerIdentity, info.GetLastWorkerIdentity())
 	require.NotNil(t, info.GetLastStartedTime())
 	protorequire.ProtoEqual(t, defaultFailure, info.GetLastFailure())
-	protorequire.ProtoEqual(t, defaultFailure, activityResp.GetFailure())
+	protorequire.ProtoEqual(t, defaultFailure, activityResp.GetOutcome().GetFailure())
 
 	if expectedHeartbeatDetails != nil {
 		protorequire.ProtoEqual(t, expectedHeartbeatDetails, info.GetHeartbeatDetails())
@@ -1770,13 +1775,13 @@ func (s *standaloneActivityTestSuite) validateBaseActivityResponse(
 	t *testing.T,
 	activityID string,
 	expectedRunID string,
-	response *workflowservice.PollActivityExecutionResponse,
+	response *workflowservice.DescribeActivityExecutionResponse,
 ) {
-	require.NotNil(t, response.StateChangeLongPollToken)
+	require.NotNil(t, response.LongPollToken)
 	require.Equal(t, activityID, response.GetInfo().GetActivityId())
 	require.Equal(t, s.tv.ActivityType(), response.GetInfo().GetActivityType())
 	require.Equal(t, expectedRunID, response.RunId)
-	require.NotNil(t, response.GetInfo().GetScheduledTime())
+	require.NotNil(t, response.GetInfo().GetScheduleTime())
 	protorequire.ProtoEqual(t, defaultInput, response.GetInput())
 }
 
@@ -1787,12 +1792,10 @@ func (s *standaloneActivityTestSuite) startActivity(ctx context.Context, activit
 		ActivityType: s.tv.ActivityType(),
 		Identity:     s.tv.WorkerIdentity(),
 		Input:        defaultInput,
-		Options: &activitypb.ActivityOptions{
-			TaskQueue: &taskqueuepb.TaskQueue{
-				Name: taskQueue,
-			},
-			StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		TaskQueue: &taskqueuepb.TaskQueue{
+			Name: taskQueue,
 		},
-		RequestId: s.tv.RequestID(),
+		StartToCloseTimeout: durationpb.New(1 * time.Minute),
+		RequestId:           s.tv.RequestID(),
 	})
 }