Presentamos Strands Labs: practique hoy enfoques experimentales de última generación para el desarrollo agente.

estamos introduciendo Laboratorios de hebrasuna nueva organización de Strands GitHub diseñada para brindar a los desarrolladores la capacidad de probar enfoques experimentales y de última generación para el desarrollo de IA agente. SDK de Strands Agents: disponible para ambos Pitón y Mecanografiado – ha ganado una tracción increíble en la comunidad de desarrolladores desde que lo lanzamos como código abierto en mayo de 2025. El SDK se ha descargado más de 14 millones de veces y el equipo de AWS ha trabajado arduamente para agregar nuevas funciones, incluidos experimentos como Gobiernopara apoyar a una comunidad de desarrolladores muy activa. El enfoque basado en modelos de Strands ha demostrado ser simple, potente y escalable para todo, desde la creación de prototipos hasta cargas de trabajo de producción empresarial. Obtenga más información sobre Strands y el enfoque basado en modelos aquí.

Hemos elegido hacer de Strands Labs una organización GitHub separada para fomentar la innovación a través de la experimentación y ampliar la frontera del desarrollo agente. También abrimos Strands Labs a todos los equipos de desarrollo de Amazon, lo que significa que todos pueden contribuir con sus proyectos innovadores de código abierto para uso y comentarios de la comunidad. Este modelo fomentará una experimentación, un aprendizaje y un crecimiento más rápidos para la comunidad de desarrolladores de Strands, sin acoplar los experimentos al SDK de Strands y su ciclo de lanzamiento de uso en producción. Puede esperar que todos los proyectos de Strands-Labs se envíen con casos de uso claros, código funcional y pruebas para ayudarle a comenzar.

En el lanzamiento, pondremos a disposición Strands Labs con tres proyectos. El primero es Robotsel segundo es Simulación de robots y el tercero es Funciones de IA.

1. Robots: Con Robots, estamos explorando cómo los agentes de IA se extienden al borde y al mundo físico, donde no solo procesan información sino que interactúan con el entorno físico que nos rodea. A través de una interfaz unificada de Strands Agents, los agentes físicos de IA pueden controlar diversos robots conectando capacidades de IA directamente a sensores físicos y hardware.
2. Simulación de robots: Robots Sim integra sus robots agentes con mundos simulados en 3D habilitados para la física, lo que permite la creación rápida de prototipos y el desarrollo de algoritmos en un entorno seguro y simulado sin necesidad de hardware robótico físico. Es perfecto para iterar estrategias de agentes, probar políticas de modelos de visión-lenguaje-acción (VLA) y validar enfoques antes de la implementación en el mundo real.
3. Funciones de IA: Las funciones de IA permiten a los desarrolladores definir un agente utilizando especificaciones de lenguaje natural en lugar de código, escribiendo condiciones previas y posteriores en Python que validan el comportamiento y generan implementaciones funcionales. Este experimento tiene como objetivo reducir la brecha de confianza al generar código con LLM al centrar el tiempo del desarrollador en cómo validar su intención y dejar que el marco haga el resto.

Profundicemos en cada uno de estos a continuación para mostrar cómo estos proyectos amplían la frontera del desarrollo agente.

Robots de hebras

Los sistemas de IA agente se están expandiendo rápidamente más allá del mundo digital y hacia el dominio físico, donde los agentes de IA perciben, razonan y actúan en entornos reales. A medida que los sistemas de IA interactúan cada vez más con el mundo físico a través de la robótica, los vehículos autónomos y la infraestructura inteligente, surge una pregunta fundamental: ¿Cómo construimos agentes que aprovechen la computación masiva en la nube para un razonamiento complejo y al mismo tiempo mantengan una capacidad de respuesta de milisegundos para la detección y actuación física?

Strands Robots proporciona la capa de orquestación, inteligencia e infraestructura, transformando dispositivos de borde individuales en sistemas de IA físicos coordinados y agentes. A través de este proyecto, nuestro objetivo es democratizar la IA física a través de API simples, bibliotecas de código abierto y servicios administrados.

Strands Robots amplía la capacidad de Strands Agents para que los agentes de IA controlen robots físicos a través de una interfaz unificada de Strands Agents que conecta los agentes de IA con sensores físicos y hardware. También permite la creación rápida de prototipos y el desarrollo de algoritmos en un entorno seguro y simulado sin necesidad de hardware robótico físico, lo cual es perfecto para iterar estrategias de agentes, probar políticas de VLA y validar enfoques antes de la implementación en el mundo real.

En esta demostración de laboratorio, un brazo robótico SO-101 maneja la manipulación con el NVIDIA GR00T modelo visión-lenguaje-acción (VLA). El modelo VLA combina percepción visual, comprensión del lenguaje y predicción de acciones en un solo modelo. GR00T toma imágenes de la cámara, posiciones de las articulaciones del robot e instrucciones de lenguaje como entrada y genera directamente nuevas posiciones de las articulaciones objetivo. En asociación con NVIDIA, integramos NVIDIA GR00T con Strands Agents y demostramos que el agente Strands se ejecuta en Supersónico NVIDIA hardware de vanguardia para controlar el brazo robótico SO-101, mostrando cómo las capacidades sofisticadas de IA pueden ejecutarse directamente en sistemas integrados.

Además nos integramos con Abrazando el LeRobot de Face que proporciona interfaces de datos y hardware que hacen accesible el trabajo con hardware robótico. Al combinar abstracciones de hardware como LeRobot con modelos VLA (por ejemplo, NVIDIA GR00T), podemos crear aplicaciones de IA de vanguardia que perciben, razonan y actúan en el mundo físico.

Como parte de esta iniciativa y para facilitar esto a los constructores, hemos lanzado una clase de Robot experimental con una interfaz sencilla para conectar hardware a modelos VLA como NVIDIA GR00T. Por ejemplo, para implementar un agente en un dispositivo de borde para utilizar el modelo NVIDIA GR00T VLA junto con el brazo robótico SO-101 para una tarea como “recoger y colocar una manzana en una canasta”, la clase Strands Robot se puede emplear como:

from strands import Agent 
from strands_robots import Robot 

# Create robot with cameras 
robot = Robot( 
    tool_name="my_arm", 
    robot="so101_follower", 
    cameras={ 
        "front": {"type": "opencv", "index_or_path": "/dev/video0", "fps": 30}, 
        "wrist": {"type": "opencv", "index_or_path": "/dev/video2", "fps": 30} 
    }, 
    port="/dev/ttyACM0", 
    data_config="so100_dualcam" 
) 

# Create agent with robot tool 
agent = Agent(tools=[robot]) 
agent("place the apple in the basket") 

La clase Robot que se ejecuta en dispositivos perimetrales puede delegar razonamientos complejos a la nube mediante LLM y otros modelos cuando sea necesario. Los modelos VLA proporcionan control a nivel de milisegundos para acciones físicas, pero cuando el sistema encuentra situaciones que requieren un razonamiento más profundo (como planificar tareas de varios pasos o tomar decisiones basadas en patrones históricos) puede consultar agentes basados ​​en la nube más potentes.

Hebras Robot Sim

Strands Robot Simulation proporciona un entorno para la creación rápida de prototipos de robótica agente sin necesidad de hardware robótico físico. Admite entornos de referencia Libero, soporte de políticas VLA saac-GR00T a través de ZMQ, una interfaz extensible para proveedores de VLA, captura de episodios de simulación como videos MP4, simulación sin bloqueo con monitoreo de estado, pruebas rápidas sin dependencias y administración de servicios de inferencia GR00T. Este proyecto de simulación actualmente admite dos modos de ejecución: ejecución de episodio completo con resultados finales y control iterativo con retroalimentación visual por lote. El diseño modular de Strands Robot Simulation permite a los desarrolladores intercambiar implementaciones de políticas o entornos de simulación sin reestructurar la lógica central. El circuito de control ejecuta pasos secuencialmente, recopila observaciones de cámaras y sensores conjuntos, y alimenta estos datos a modelos de políticas que generan comandos motores dentro de horizontes de acción de tamaño fijo.

Por ejemplo, el siguiente ejemplo ilustra cómo utilizar la clase SimEnv de strands_robots_sim para controlar robots simulados dentro de entornos Libero empleando políticas generadas por NVIDIA GR00T. Este ejemplo supone que Libero está instalado, el servicio de inferencia GR00T está operativo en el puerto 8000 y se puede acceder a Docker con contenedores isaac-gr00t.

import asyncio 
import argparse 
import random 
from strands import Agent 
from strands_robots_sim import SimEnv, gr00t_inference 
 
def main(max_episodes=10): 
    # Create simulation environment 
    sim_env = SimEnv( 
        tool_name="my_libero_sim", 
        env_type="libero", 
        task_suite="libero_10", 
        data_config="libero_10" 
    ) 
 
    # Create agent 
    agent = Agent(tools=[sim_env, gr00t_inference]) 
 
    try: 
       # Start GR00T inference 
        result = agent.tool.gr00t_inference( 
            action="start", 
            checkpoint_path="/data/checkpoints/gr00t-n1.5-libero-long-posttrain", 
            port=8000, 
            data_config="examples.Libero.custom_data_config:LiberoDataConfig" 
        )         
 
        async def init_sim_env(): 
            return await sim_env.sim_env.initialize() 
 
        if not asyncio.run(init_sim_env()): 
            raise RuntimeError("Failed to initialize simulation environment") 
 
        # Randomly select a task 
        selected_task = random.choice(sim_env.sim_env.available_tasks) 
 
        # Set the task name in the environment 
        sim_env.sim_env.set_task_name(selected_task) 
 
        # Control simulated robot with natural language 
        agent(f"Run the task '{selected_task}' for {max_episodes} episode(s) with max_steps_per_episode=500 and record video") 
 
        # Check final status 
        final_status = agent.tool.my_libero_sim(action="status") 
        print(f"Final status: {final_status}") 
    except Exception as e: 
        print(f"Example failed with error: {e}")         
        print("- Install simulation dependencies: pip install strands-robots[sim]")
 
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Run Libero simulation with GR00T policy') 
    parser.add_argument('--max-episodes', type=int, default=10, 
                        help='Maximum number of episodes to run (default: 10)') 
    args = parser.parse_args() 
    main(max_episodes=args.max_episodes)

Funciones de IA

AI Functions presenta una nueva forma de escribir código con agentes en la que se escriben funciones de Python con especificaciones de lenguaje natural en lugar de código. Usando el decorador @ai_function, usted define lo que quiere que haga una función a través de la descripción y las condiciones de validación. AI Functions aprovecha el bucle del agente de Strands para generar la implementación, validar el resultado y volver a intentarlo automáticamente si la validación falla. Considere cargar datos de facturas desde archivos en formatos desconocidos. Los enfoques tradicionales requieren determinar el formato del archivo, escribir la lógica de transformación para cada formato, crear mensajes, analizar respuestas y orquestar reintentos cuando falla la validación. Por lo general, esto implica docenas de líneas de código y es posible que no represente todos los escenarios. Con AI Functions, escribe una pequeña función que describe el resultado deseado y una función de validación que expresa cómo se ve el éxito. El LLM determina el formato del archivo, escribe el código de transformación y devuelve un objeto Python DataFrame real.

from ai_functions import ai_function  
from pandas import DataFrame, api  

def check_invoice_dataframe(df: DataFrame):  
    """Post-condition: validate DataFrame structure."""  
    assert {'product_name', 'quantity', 'price', 'purchase_date'}.issubset(df.columns)  
    assert api.types.is_integer_dtype(df['quantity']), "quantity must be an integer"  
    assert api.types.is_float_dtype(df['price']), "price must be a float"  
    assert api.types.is_datetime64_any_dtype(df['purchase_date']), "purchase_date must be a datetime64"  
    assert not df.duplicated(subset=['product_name', 'price', 'purchase_date']).any(), "The combination of product_name, price, and purchase_date must be unique"  

# code execution has to be explicitly enabled   
@ai_function(  
    code_execution_mode="local",  
    code_executor_additional_imports=["pandas.*", "sqlite3", "json"],  
    post_conditions=[check_invoice_dataframe],  
)  
def import_invoice(path: str) -> DataFrame:  
    """  
    The file `{path}` contains purchase logs. Extract them in a DataFrame with columns:  
    - product_name (str)  
    - quantity (int)  
    - price (float)  
    - purchase_date (datetime)  
    """  

@ai_function(  
    code_execution_mode="local",  
    code_executor_additional_imports=["pandas.*"],  
)  
def fuzzy_merge_products(invoice: DataFrame) -> DataFrame:  
    """  
    Find product names that denote different versions of the same product, normalize them  
    by removing version suffixes and unifying spelling variants, update the product names  
    with the normalized names, and return a DataFrame with the same structure   
    (same columns and rows).  
    """  

# Load a JSON (the agent has to inspect the JSON to understand how to map it to a DataFrame)  
df = import_invoice('data/invoice.json')  
print("Invoice total:", df['price'].sum())  

# Load a SQLite database. The agent will dynamically check the schema and generate  
# the necessary queries to read it and convert it to the desired format)  
df = import_invoice('data/invoice.sqlite3')  
# Merge revisions of the same product  
df = fuzzy_merge_products(df) 

A medida que avancemos, esperamos compartir más proyectos a través de Strands-Labs con la comunidad de desarrolladores de Strands y esperamos sus comentarios para seguir mejorando Strands.

Sumérjase en estos nuevos enfoques de IA agente y comience a experimentar hoy en Laboratorios de hebras.