The Strands Agents SDK supports mixing Graph, Workflow, and Swarm orchestrators in a single process, but the composition is brittle. Verified on 2026-11-20 against strands-agents 1.63.0 and strands-agents-tools 0.8.11, the integration relies entirely on text serialization. There is no shared context object; the boundary is a rendering step where structured data collapses into strings. This design choice has immediate implications for reliability and cost in production agent stacks.
The Text-Only Bottleneck
The core finding is that the three orchestrators do not share state. A Graph node passes results via str(NodeResult), a Workflow tool passes data via rendered strings, and a Swarm passes context via a serialized dictionary. Because the next orchestrator only reads text, condition predicates in downstream steps cannot inspect structured fields like status or token counts. If your logic needs to branch on a specific error code or metric, a mixed run fails because the data is flattened before it crosses the boundary.
Failure Swallowing and Audit Gaps
Silent failures are a critical risk. In experiment E7, a tool raising an exception inside a nested Swarm left the outer Graph marked as completed. Similarly, experiment E8 showed the Workflow tool reporting 100.0% success while one task recorded an error on disk. Only agent-level exceptions that escape the inner loop propagate to the outer Graph. For compliance or auditable workflows, relying on a text string that says 'success' is dangerous when the underlying structured status contradicts it.
The Cost of Composition
Mixing orchestrators is expensive. The baseline pure Graph run (E1) used 4,829 total tokens and took 10.179 seconds. In contrast, the mixed runs consumed 74.5% and 192.8% more model tokens, with wall clock time increasing up to 3.02x. The overhead comes from re-rendering context and the lack of direct data access, which forces the agents to parse text rather than read objects. If you need deterministic scheduling with one layer of autonomous handoffs, this shape works, but do not expect efficiency.
Key Takeaways
- Adapters are the work: You must write custom code to move values between the Graph's NodeResult, the Workflow's task_results, and the Swarm's SharedContext.
- No shared memory: Even in one process, orchestrators communicate via serialized text, breaking structured data integrity.
- Failures are hidden: Inner tool errors can be swallowed, reporting false success to the outer orchestrator.
- High token overhead: Mixed runs cost up to 192.8% more tokens than a pure Graph baseline.
The Bottom Line
Do not mix orchestrators for the sake of architecture; do it only if you need a deterministic Graph containing one layer of autonomous Swarm handoffs. Otherwise, the text-only boundary introduces unnecessary cost and audit risks that pure implementations avoid.