Skip to lesson
supraj.dev THE ENGINEERING HANDBOOKS
LEARN / BUILD / VERIFY2026 edition · checked 06 Oct

CHAPTER 27 / 30 · Operate with evidence

Choose a deployment that matches the workload

Separate control and execution responsibilities, and plan durability before choosing a hosting product.

4 min read + practiceWorked exerciseInterview practice

The mechanism

Deploying an agent is more than placing Python in a container. The service needs authentication, request admission, model access, tool permissions, state, cancellation, telemetry and recovery. A short read-only request and a long-running engineering task have different runtime requirements. Choose the operating model before choosing a hosting logo.

A useful architecture separates a control plane that authenticates and approves work from an execution plane that runs the agent with scoped capabilities. This is an application design pattern, not an automatic Strands feature. The executor receives a concrete task contract and returns evidence; it should not be able to enlarge its own permissions.

API / identity / policy
Queue or request admission
Scoped agent worker
Evidence + status store

A worked deployment decision

WorkloadCandidate operating modelQuestions to answer
Short incident explanationRequest-serving processTimeout, streaming, concurrency, quotas
Long investigationDurable job and workerResume, cancellation, leases, retention
Untrusted generated codeSeparate execution boundaryFilesystem, network, credentials, cleanup
Human-approved changeProposal and executor splitApproval binding, idempotency, audit

Official Strands guides cover several targets, including containers and Amazon Bedrock AgentCore. Those services have their own availability, identity, networking, persistence and pricing requirements. This handbook does not provision resources or claim that any particular account has access.

A local session directory is not durable merely because it worked on a laptop. Hosted filesystems may be ephemeral or isolated per replica. Store durable state in an appropriate backend, bind it to the authenticated tenant and test restart and concurrent access behavior in the actual environment.

Practice: conduct a paper deployment review

Offline. Draw ParcelOps as a read-only service. Mark where credentials are obtained, where the model is invoked, where incident access is authorized and where session data persists. Add a request deadline, queue limit and maximum admitted concurrency. Keep numbers labelled as proposed policy, not measured capacity.

Expected observation: a provider quota can become the bottleneck before CPU does. Increasing worker count may increase throttling and cost without improving throughput. Define backpressure so the system can reject or defer work instead of accepting unlimited requests.

Now draw a process crash during a tool call and a deployment rollout during a paused approval. Specify which records survive and how the next worker finds them. Include a rollback plan that accounts for schema compatibility; rolling back code does not automatically roll back stored state.

A release checklist with concrete evidence

Artifact: immutable build digest recorded
Configuration: model, tools and policy versions recorded
Identity: least-privilege runtime role reviewed
State: restart and ownership tests recorded
Limits: request, loop and tool budgets tested
Telemetry: redaction and correlation verified
Rollback: previous artifact and schema compatibility known

These are evidence requirements, not completed claims. Attach a test result or review record to each item before declaring it satisfied. Avoid decorative checkmarks that imply unperformed validation.

Troubleshooting and trade-offs

If local behavior differs from hosted behavior, compare runtime, dependencies, credentials, region, network path and storage semantics. Do not copy a developer’s entire environment into production to make errors disappear. Use service-specific identity and scoped configuration.

Serverless, containers and managed agent runtimes each impose constraints. Evaluate request duration, warmup, streaming, background execution, observability and total cost. Prefer the simplest model that meets the tested workload; add orchestration only when its durability or isolation benefits are needed.

Interview practice

Why separate control and execution planes?

It keeps authentication, policy and approval decisions in a trusted service while workers receive scoped task contracts. It also clarifies admission, cancellation, evidence collection and recovery responsibilities.

Why can scaling workers make an agent service slower?

More concurrency can exceed model or downstream quotas, increasing throttling and retries. Queueing, shared state and external bottlenecks must be measured; CPU capacity alone is not the throughput limit.

Completion check

Produce an architecture with ownership, data flows and failure paths. Identify one hosting prerequisite that remains unverified and one test required before a real deployment. No cloud resources need to be created for this exercise.

Sources and version notes

Checked 6 October 2026. Python examples target strands-agents==1.58.0 unless labelled otherwise. Live documentation can change; compare your installed version before adapting an example.

YOUR NEXT STEP

Make the understanding yours.

Use the completion check above. Mark this chapter when you can explain the mechanism and its limits.

Self-assessed reading progress. This does not certify that a lab ran or a system is secure.