Strands Agents + Ertas

Build agents with Strands Agents — AWS's open-source SDK that uses model-driven planning over hard-coded workflows, with full support for Ertas-trained local models alongside Bedrock and Anthropic APIs.

Overview

Strands Agents is AWS's open-source agent SDK, released as part of the broader push to give AWS customers a first-party alternative to LangChain and CrewAI. Its defining design choice is to lean on model-driven planning rather than hand-coded workflow graphs — agents reason about what to do next based on the model's understanding of the task, with the SDK handling tool execution, retries, and observability around that reasoning loop. By May 2026 the SDK had crossed 14M total downloads in under a year, partly because of its use inside AWS's own products (Amazon Q, AWS Glue, Amazon Connect Contact Lens). The TypeScript SDK reached 1.0 GA on May 1, 2026, bringing parity with the Python runtime for Node.js and browser environments — particularly relevant for mobile-app backends and Vercel/Cloudflare edge deployments.

The framework's lightweight design is intentional. Where LangGraph requires upfront graph definition and CrewAI requires explicit role/goal setup, Strands lets the model figure out the workflow at runtime, with the SDK providing the scaffolding (tool calling, observability, retries) around that decision-making. For straightforward agentic tasks this produces less code and faster development; for highly structured workflows where the model's planning is unreliable, teams can layer custom orchestration on top.

Strands is model-agnostic. The SDK ships with first-class providers for Amazon Bedrock, Anthropic, OpenAI, and Ollama, plus a generic LiteLLM provider that adapts to any OpenAI-compatible endpoint. For teams that want AWS's developer ergonomics and observability story but plan to deploy on self-hosted models — for cost or data-sovereignty reasons — the integration with Ertas-trained inference is a few lines of configuration.

How Ertas Integrates

Ertas-trained models work with Strands Agents through its OllamaModel provider or its generic LiteLLM provider. After fine-tuning in Studio and exporting to GGUF, you serve the model via Ollama, vLLM, or Ertas Cloud, then configure Strands' agent with the appropriate provider pointed at your endpoint. The model-driven planning, observability, and retry primitives all work transparently.

The model-driven planning approach is particularly powerful with fine-tuned models. A general-purpose 7B–14B model often makes inconsistent planning decisions on domain-specific tasks, which forces teams toward more explicit orchestration. An Ertas-trained model whose training data includes representative planning traces from the target domain produces more consistent and competent planning — letting Strands' lightweight design hold up in production rather than degrading to ad-hoc workarounds.

For teams already in the AWS ecosystem who want to control inference costs, Strands + Ertas-trained model on EC2 (or on-premise) produces an agent stack that fits the AWS architecture while keeping per-task economics fixed. Observability flows into Amazon CloudWatch and AWS X-Ray; tracing data feeds back into Studio for incremental fine-tuning.

Getting Started

1
Fine-tune a domain-specific model in Ertas Studio
Train on data that includes representative planning traces from your target domain. Strands relies on the model for planning decisions, so training data quality directly improves agent reliability.
2
Deploy to an OpenAI-compatible endpoint
Export to GGUF and serve via Ollama, vLLM, or Ertas Cloud. Strands' OllamaModel provider connects directly; the LiteLLM provider connects to any compatible alternative.
3
Install Strands Agents and configure the model
Install strands-agents. Create an Agent configured with the OllamaModel (or LiteLLM) provider pointed at your inference endpoint.
4
Define tools as typed Python functions
Add tools using Strands' @tool decorator. Strands' lightweight design means little boilerplate — function signature and docstring are usually sufficient for the model to use the tool correctly.
5
Run with built-in observability
Call the agent. Tracing flows into AWS X-Ray (or your observability backend). Iterate on the agent's planning behavior by inspecting traces and feeding back into Studio for the next training round.

python

from strands import Agent, tool
from strands.models.ollama import OllamaModel

# Point Strands at your Ertas-trained model served via Ollama
model = OllamaModel(
    host="http://localhost:11434",
    model_id="ertas-aws-ops-7b",
)

@tool
def list_running_instances(region: str) -> list[dict]:
    """Return a list of running EC2 instances in a region."""
    return ec2.list_instances(region, state="running")

@tool
def stop_instance(instance_id: str) -> dict:
    """Stop an EC2 instance by ID."""
    return ec2.stop(instance_id)

agent = Agent(
    model=model,
    tools=[list_running_instances, stop_instance],
    system_prompt="You manage EC2 fleets — find idle instances and stop them when asked.",
)

# Strands lets the model plan the multi-step workflow itself
result = agent("Find any t3.micro instances in us-west-2 that have been idle for >24h and stop them.")
print(result.message)

Build an EC2-management agent with Strands Agents and an Ertas-trained 7B model. Strands handles the planning loop; the fine-tuned model provides domain-specific competence.

Benefits

Model-driven planning — less orchestration code than LangGraph or CrewAI
Lightweight SDK — minimal conceptual overhead
First-class AWS integration — Bedrock, CloudWatch, X-Ray observability
Multi-provider model support: Bedrock, Anthropic, OpenAI, Ollama, generic LiteLLM
Production-tested in AWS's own products (Amazon Q, Glue, Connect)
Pairs with Ertas fine-tuning to make model-driven planning reliable on domain tasks