curl -sS --fail-with-body https://haijun.my.id/v1/environments \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d '{
      "name": "self-hosted",
      "config": {"type": "self_hosted"}
    }'

    ant apply environment.yaml

      # yaml-language-server: $schema=https://platform.juglow.my.id/schemas/ant/beta/environment.json
      name: self-hosted
      config:
        type: self_hosted

  client = juglow.Juglow()

  environment = client.beta.environments.create(
      name="self-hosted", config={"type": "self_hosted"}
  )
  print(environment.id)

  const client = new Juglow();

  const environment = await client.beta.environments.create({
    name: "self-hosted",
    config: { type: "self_hosted" }
  });
  console.log(environment.id);

  using Juglow.Models.Beta.Environments;

  var client = new JuglowClient();

  var environment = await client.Beta.Environments.Create(
      new EnvironmentCreateParams
      {
          Name = "self-hosted",
          Config = new BetaSelfHostedConfigParams(),
      }
  );
  Console.WriteLine(environment.ID);

  client := juglow.NewClient()

  environment, err := client.Beta.Environments.New(context.Background(), juglow.BetaEnvironmentNewParams{
  	Name: "self-hosted",
  	Config: juglow.BetaEnvironmentNewParamsConfigUnion{
  		OfSelfHosted: &juglow.BetaSelfHostedConfigParams{},
  	},
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(environment.ID)

  import com.juglow.models.beta.environments.BetaSelfHostedConfigParams;
  import com.juglow.models.beta.environments.EnvironmentCreateParams;

  void main() {
      var client = JuglowOkHttpClient.fromEnv();

      var environment = client.beta().environments().create(
          EnvironmentCreateParams.builder()
              .name("self-hosted")
              .config(BetaSelfHostedConfigParams.builder().build())
              .build()
      );
      IO.println(environment.id());
  }

  $client = new Juglow\Client();

  $environment = $client->beta->environments->create(
      name: 'self-hosted',
      config: ['type' => 'self_hosted'],
  );
  echo $environment->id, PHP_EOL;

  client = Juglow::Client.new

  environment = client.beta.environments.create(
    name: "self-hosted",
    config: {type: :self_hosted}
  )
  puts environment.id

export JUGLOW_ENVIRONMENT_KEY="sk-ant-oat01-..."
export JUGLOW_ENVIRONMENT_ID="env_..."

    VERSION=1.35.0
    OS=$(uname -s | tr '[:upper:]' '[:lower:]')
    case $(uname -m) in
      x86_64) ARCH=amd64 ;;
      aarch64) ARCH=arm64 ;;
    esac
    curl -fsSL "https://github.com/juglows/juglow-cli/releases/download/v${VERSION}/ant_${VERSION}_${OS}_${ARCH}.tar.gz" \
      | sudo tar -xz -C /usr/local/bin ant

ant beta:worker poll --workdir "/workspace"

FROM your-base-image
ARG ANT_VERSION=1.35.0
ARG TARGETARCH
RUN ARCH=$([ "$TARGETARCH" = "arm64" ] && echo arm64 || echo amd64) && \
    curl -fsSL "https://github.com/juglows/juglow-cli/releases/download/v${ANT_VERSION}/ant_${ANT_VERSION}_linux_${ARCH}.tar.gz" \
      | tar -xz -C /usr/local/bin ant
WORKDIR /workspace
VOLUME /workspace
ENTRYPOINT ["ant", "beta:worker", "run"]

#!/bin/bash
# spawn.sh: called once per claimed work item
mkdir -p "/host/outputs/$JUGLOW_SESSION_ID"
exec docker run --rm \
  -e JUGLOW_SESSION_ID -e JUGLOW_ENVIRONMENT_KEY \
  -e JUGLOW_WORK_ID -e JUGLOW_ENVIRONMENT_ID -e JUGLOW_BASE_URL \
  -v "/host/outputs/$JUGLOW_SESSION_ID":/workspace \
  your-image

ant beta:worker poll --on-work ./spawn.sh

  import asyncio
  import contextlib
  import os
  import signal
  from juglow import AsyncJuglow
  from juglow.lib.environments import EnvironmentWorker

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      async with AsyncJuglow(auth_token=environment_key) as client:
          worker = EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
          )
          task = asyncio.create_task(worker.run())
          # Cancelling the task, rather than killing the process, lets the worker stop its
          # in-flight work item and upload changed memory files before it exits.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });
  const controller = new AbortController();
  // Aborting on either signal lets the worker upload changed memory files and remove its
  // store directories before the process exits.
  process.once("SIGINT", () => controller.abort());
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal
  }).run();

  // EnvironmentWorker is not currently available in the C# SDK. See the Always-on (ant CLI) tab.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  )

  func main() {
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker is not currently available in the Java SDK. See the Always-on (ant CLI) tab.

  // EnvironmentWorker is not currently available in the PHP SDK. See the Always-on (ant CLI) tab.

  # EnvironmentWorker is not currently available in the Ruby SDK. See the Always-on (ant CLI) tab.

export JUGLOW_WEBHOOK_SIGNING_KEY="whsec_..."

  import asyncio
  import os
  import juglow
  import standardwebhooks  # installed by the juglow[webhooks] extra

  environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
  environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
  client = juglow.AsyncJuglow(
      auth_token=environment_key,
  )
  # Cancelled by shutdown() so an in-flight work item can upload changed memory files and
  # remove its store directories before the process exits.
  inflight: set[asyncio.Task[None]] = set()

  # Await this from the host's shutdown hook, such as an ASGI lifespan shutdown (the code after
  # `yield` in a FastAPI lifespan), which uvicorn runs on SIGTERM. uvicorn lets open requests
  # finish before that hook runs, so set --timeout-graceful-shutdown to bound the wait.
  async def shutdown() -> None:
      for task in inflight:
          task.cancel()
      await asyncio.gather(*inflight, return_exceptions=True)

  async def handle(raw: bytes, headers: dict[str, str]) -> tuple[dict[str, str], int]:
      try:
          event = client.beta.webhooks.unwrap(raw.decode(), headers=headers)
      except standardwebhooks.WebhookVerificationError:
          return {"error": "signature verification failed"}, 401
      if event.data.type != "session.status_run_started":
          return {"status": "ignored"}, 200
      task = asyncio.create_task(run_queued_work())
      inflight.add(task)
      task.add_done_callback(inflight.discard)
      try:
          # Shielded: a dropped or timed-out delivery must not cancel the item; shutdown() does.
          await asyncio.shield(task)
      except asyncio.CancelledError:
          return {"status": "shutting down"}, 503
      return {"status": "ok"}, 200

  async def run_queued_work() -> None:
      async for work in client.beta.environments.work.poller(
          environment_id=environment_id,
          environment_key=environment_key,
          block_ms=None,
          reclaim_older_than_ms=2000,
          drain=True,
          auto_stop=False,
      ):
          await client.beta.environments.work.worker(workdir="/workspace").handle_item(
              work_id=work.id,
              environment_id=environment_id,
              session_id=work.data.id,
              environment_key=environment_key,
              # The per-session secret is what lets the worker mount the session's memory stores.
              work_secret=work.secret,
          )

  import Juglow from "@juglow-ai/sdk";

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({
    authToken: environmentKey
  });
  // Call shutdown.abort() from the host's SIGTERM/SIGINT handler, alongside closing the server,
  // then wait for in-flight handle() calls before exiting: the abort lets a running work item
  // upload changed memory files and remove its store directories first.
  export const shutdown = new AbortController();

  export async function handle(req: Request): Promise<Response> {
    // Never acknowledge a delivery whose work will not run here; a 503 makes the sender retry.
    if (shutdown.signal.aborted) {
      return Response.json({ status: "shutting down" }, { status: 503 });
    }
    const body = await req.text();
    let event;
    try {
      event = client.beta.webhooks.unwrap(body, { headers: Object.fromEntries(req.headers) });
    } catch {
      return new Response("signature verification failed", { status: 401 });
    }
    if (event.data.type !== "session.status_run_started") {
      return Response.json({ status: "ignored" });
    }

    for await (const work of client.beta.environments.work.poller({
      environmentId,
      environmentKey,
      blockMs: null,
      reclaimOlderThanMs: 2000,
      drain: true,
      autoStop: false,
      signal: shutdown.signal
    })) {
      await client.beta.environments.work.worker({ workdir: "/workspace" }).handleItem({
        workId: work.id,
        environmentId,
        sessionId: work.data.id,
        environmentKey,
        // The per-session secret is what lets the worker mount the session's memory stores.
        workSecret: work.secret ?? undefined,
        signal: shutdown.signal
      });
    }
    // The poller and handleItem return quietly on abort, so a drain cut short lands here.
    if (shutdown.signal.aborted) {
      return Response.json({ status: "shutting down" }, { status: 503 });
    }
    return Response.json({ status: "ok" });
  }

  // EnvironmentWorker is not currently available in the C# SDK.
  // To handle work items directly, see the Environments Work endpoints.

  package main

  import (
  	"context"
  	"encoding/json"
  	"errors"
  	"io"
  	"log/slog"
  	"net/http"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/packages/param"
  )

  var (
  	environmentKey = os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID  = os.Getenv("JUGLOW_ENVIRONMENT_ID")
  	client         = juglow.NewClient(
  		option.WithAuthToken(environmentKey),
  		option.WithWebhookKey(os.Getenv("JUGLOW_WEBHOOK_SIGNING_KEY")),
  	)
  	worker = environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		Workdir: "/workspace",
  	})
  	// Cancelled on SIGINT or SIGTERM (set in main) so an in-flight work item can
  	// upload changed memory files and remove its store directories before exit.
  	shutdown context.Context
  )

  func handle(w http.ResponseWriter, r *http.Request) {
  	body, err := io.ReadAll(r.Body)
  	if err != nil {
  		http.Error(w, "bad request", http.StatusBadRequest)
  		return
  	}
  	event, err := client.Beta.Webhooks.Unwrap(body, r.Header)
  	if err != nil {
  		http.Error(w, "signature verification failed", http.StatusUnauthorized)
  		return
  	}
  	if event.Data.Type != "session.status_run_started" {
  		json.NewEncoder(w).Encode(map[string]string{"status": "ignored"})
  		return
  	}

  	// The Go SDK does not provide a RunOne convenience: drain pending items
  	// with WorkPoller and run each one with HandleItem.
  	// Detach from r.Context(): the session can outlive the webhook delivery timeout.
  	// The process-wide shutdown context still ends the item cleanly on SIGTERM.
  	ctx := shutdown
  	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
  		EnvironmentID:      environmentID,
  		EnvironmentKey:     environmentKey,
  		BlockMs:            param.Null[int64](),
  		ReclaimOlderThanMs: param.NewOpt[int64](2000),
  		Drain:              true,
  		AutoStop:           param.NewOpt(false),
  	})
  	defer poller.Close()
  	for poller.Next() {
  		item := poller.Current()
  		if err := worker.HandleItem(ctx, environments.HandleItemOptions{
  			WorkID:         item.ID,
  			EnvironmentID:  item.EnvironmentID,
  			SessionID:      item.Data.ID,
  			EnvironmentKey: environmentKey,
  			// The per-session secret is what lets the worker mount the session's memory stores.
  			WorkSecret: item.Secret,
  		}); err != nil {
  			slog.Error("handle work item", "work_id", item.ID, "err", err)
  			http.Error(w, "internal error", http.StatusInternalServerError)
  			return
  		}
  	}
  	if err := poller.Err(); err != nil {
  		slog.Error("poll work queue", "err", err)
  		http.Error(w, "internal error", http.StatusInternalServerError)
  		return
  	}
  	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
  }

  func main() {
  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()
  	shutdown = ctx

  	server := &http.Server{Addr: ":8080"}
  	http.HandleFunc("POST /webhook", handle)
  	go func() {
  		if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
  			slog.Error("http server", "err", err)
  			os.Exit(1)
  		}
  	}()
  	// On a signal, stop accepting deliveries and return only after in-flight
  	// handlers, and therefore their work items' memory teardown, have finished.
  	<-ctx.Done()
  	if err := server.Shutdown(context.Background()); err != nil {
  		slog.Error("http shutdown", "err", err)
  	}
  }

  // EnvironmentWorker is not currently available in the Java SDK.
  // To handle work items directly, see the Environments Work endpoints.

  // EnvironmentWorker is not currently available in the PHP SDK.
  // To handle work items directly, see the Environments Work endpoints.

  # EnvironmentWorker is not currently available in the Ruby SDK.
  # To handle work items directly, see the Environments Work endpoints.

  # The work poller is an SDK helper (Python, TypeScript, Go), not a raw
  # endpoint. From the shell, use `ant beta:worker poll --on-work` instead;
  # see the Always-on (ant CLI) tab.

  # The work poller is an SDK helper (Python, TypeScript, Go), not a raw
  # endpoint. From the shell, use `ant beta:worker poll --on-work` instead;
  # see the Always-on (ant CLI) tab.

  import asyncio
  import os

  from juglow import AsyncJuglow
  from juglow.types.beta.environments import BetaSelfHostedWork

  SANDBOX_ENV = (
      "JUGLOW_ENVIRONMENT_ID",
      "JUGLOW_ENVIRONMENT_KEY",
      "JUGLOW_WORK_ID",
      "JUGLOW_SESSION_ID",
      "JUGLOW_WORK_SECRET",
      "JUGLOW_BASE_URL",  # forwarded only when set on this host
  )

  async def launch_container(work: BetaSelfHostedWork) -> None:
      print(f"claimed session {work.data.id}")
      # Replace `docker run` with your own sandbox launcher. Forward the environment
      # key (never your API key) and the work item's per-session secret: the worker
      # inside needs the secret to mount the session's memory stores.
      env = os.environ | {
          "JUGLOW_WORK_ID": work.id,
          "JUGLOW_SESSION_ID": work.data.id,
          "JUGLOW_WORK_SECRET": work.secret or "",
      }
      forward = [arg for name in SANDBOX_ENV for arg in ("-e", name)]
      launcher = await asyncio.create_subprocess_exec(
          "docker", "run", "--rm", "--detach", *forward, "your-sdk-worker-image", env=env
      )
      await launcher.wait()

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      async with AsyncJuglow(auth_token=environment_key) as client:
          async for work in client.beta.environments.work.poller(
              environment_id=environment_id,
              environment_key=environment_key,
              auto_stop=False,  # the launched sandbox owns the stop call
          ):
              await launch_container(work)

  asyncio.run(main())

  import { spawn } from "node:child_process";
  import { once } from "node:events";
  import Juglow from "@juglow-ai/sdk";
  import { WorkPoller } from "@juglow-ai/sdk/helpers/beta/environments";
  import type { BetaSelfHostedWork } from "@juglow-ai/sdk/resources/beta/environments";

  const SANDBOX_ENV = [
    "JUGLOW_ENVIRONMENT_ID",
    "JUGLOW_ENVIRONMENT_KEY",
    "JUGLOW_WORK_ID",
    "JUGLOW_SESSION_ID",
    "JUGLOW_WORK_SECRET",
    "JUGLOW_BASE_URL" // forwarded only when set on this host
  ];

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });

  async function launchContainer(work: BetaSelfHostedWork): Promise<void> {
    console.log(`claimed session ${work.data.id}`);
    // Replace `docker run` with your own sandbox launcher. Forward the environment
    // key (never your API key) and the work item's per-session secret: the worker
    // inside needs the secret to mount the session's memory stores.
    const env = {
      ...process.env,
      JUGLOW_WORK_ID: work.id,
      JUGLOW_SESSION_ID: work.data.id,
      JUGLOW_WORK_SECRET: work.secret ?? ""
    };
    const forward = SANDBOX_ENV.flatMap((name) => ["-e", name]);
    const launcher = spawn(
      "docker",
      ["run", "--rm", "--detach", ...forward, "your-sdk-worker-image"],
      { env, stdio: "inherit" }
    );
    await once(launcher, "close");
  }

  const poller = new WorkPoller({
    client,
    environmentId,
    environmentKey,
    autoStop: false // the launched sandbox owns the stop call
  });

  for await (const work of poller) {
    await launchContainer(work);
  }

  // A work-polling helper is not currently available in the C# SDK.
  // To claim work directly, see the Environments Work endpoints.

  package main

  import (
  	"context"
  	"fmt"
  	"log"
  	"os"
  	"os/exec"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/packages/param"
  )

  var sandboxEnv = []string{
  	"JUGLOW_ENVIRONMENT_ID",
  	"JUGLOW_ENVIRONMENT_KEY",
  	"JUGLOW_WORK_ID",
  	"JUGLOW_SESSION_ID",
  	"JUGLOW_WORK_SECRET",
  	"JUGLOW_BASE_URL", // forwarded only when set on this host
  }

  func launchContainer(ctx context.Context, work *juglow.BetaSelfHostedWork) error {
  	fmt.Printf("claimed session %s\n", work.Data.ID)
  	// Replace `docker run` with your own sandbox launcher. Forward the environment
  	// key (never your API key) and the work item's per-session secret: the worker
  	// inside needs the secret to mount the session's memory stores.
  	args := []string{"run", "--rm", "--detach"}
  	for _, name := range sandboxEnv {
  		args = append(args, "-e", name)
  	}
  	launcher := exec.CommandContext(ctx, "docker", append(args, "your-sdk-worker-image")...)
  	launcher.Env = append(os.Environ(),
  		"JUGLOW_WORK_ID="+work.ID,
  		"JUGLOW_SESSION_ID="+work.Data.ID,
  		"JUGLOW_WORK_SECRET="+work.Secret,
  	)
  	launcher.Stdout, launcher.Stderr = os.Stdout, os.Stderr
  	return launcher.Run()
  }

  func main() {
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	ctx := context.Background()

  	poller := environments.NewWorkPoller(ctx, client, environments.WorkPollerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		AutoStop:       param.NewOpt(false), // the launched sandbox owns the stop call
  	})
  	defer poller.Close()

  	for work, err := range poller.All() {
  		if err != nil {
  			log.Fatal(err)
  		}
  		if err := launchContainer(ctx, work); err != nil {
  			log.Fatal(err)
  		}
  	}
  }

  // A work-polling helper is not currently available in the Java SDK.
  // To claim work directly, see the Environments Work endpoints.

  // A work-polling helper is not currently available in the PHP SDK.
  // To claim work directly, see the Environments Work endpoints.

  # A work-polling helper is not currently available in the Ruby SDK.
  # To claim work directly, see the Environments Work endpoints.

  EnvironmentWorker(client, ..., tools=lambda env: [beta_bash_tool(env), my_custom_tool])

  new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    tools: (ctx) => [betaBashTool(ctx), myCustomTool]
  });

  // EnvironmentWorker is not currently available in the C# SDK.
  // To answer custom tool calls directly, see the session event stream.

  worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  	EnvironmentID:  environmentID,
  	EnvironmentKey: environmentKey,
  	ToolsFunc: func(env *agenttoolset.AgentToolContext) []juglow.BetaTool {
  		return []juglow.BetaTool{agenttoolset.BetaBashTool(env), myCustomTool}
  	},
  })

  // EnvironmentWorker is not currently available in the Java SDK.
  // To answer custom tool calls directly, see the session event stream.

  // EnvironmentWorker is not currently available in the PHP SDK.
  // To answer custom tool calls directly, see the session event stream.

  # EnvironmentWorker is not currently available in the Ruby SDK.
  # To answer custom tool calls directly, see the session event stream.

  from juglow.lib.tools.agent_toolset import (
      AgentToolContext,
      beta_agent_toolset_20260401,
  )

  async with AgentToolContext(
      workdir="/workspace", client=client, session_id=work.data.id
  ) as env:
      # tracks downloaded to /workspace/tracks/<name>/
      tools = beta_agent_toolset_20260401(env)

  import {
    setupSkills,
    betaAgentToolset20260401
  } from "@juglow-ai/sdk/tools/agent-toolset/node";

  const ctx = { workdir: "/workspace", client, sessionId: work.data.id };
  await setupSkills(ctx);
  const tools = betaAgentToolset20260401(ctx);

  // AgentToolContext is not currently available in the C# SDK.

  env := &agenttoolset.AgentToolContext{Workdir: "/workspace"}
  if err := env.SetupSkills(ctx, client, work.Data.ID); err != nil {
  	panic(err)
  }
  // tracks downloaded to /workspace/tracks/<name>/
  tools := agenttoolset.BetaAgentToolset20260401(env)

  // AgentToolContext is not currently available in the Java SDK.

  // AgentToolContext is not currently available in the PHP SDK.

  # AgentToolContext is not currently available in the Ruby SDK.

ant beta:environments:work stats --environment-id "$JUGLOW_ENVIRONMENT_ID"

  curl -sS --fail-with-body https://haijun.my.id/v1/sessions \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    -d @- <<EOF
  {
    "agent": "$AGENT_ID",
    "environment_id": "$JUGLOW_ENVIRONMENT_ID",
    "metadata": {"input_file": "s3://my-bucket/data.csv"}
  }
  EOF

  ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$JUGLOW_ENVIRONMENT_ID" \
    --metadata '{"input_file": "s3://my-bucket/data.csv"}'

  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      metadata={"input_file": "s3://my-bucket/data.csv"},
  )

  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    metadata: { input_file: "s3://my-bucket/data.csv" }
  });

  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Metadata = new Dictionary<string, string> { ["input_file"] = "s3://my-bucket/data.csv" },
  });

  session, err := client.Beta.Sessions.New(ctx, juglow.BetaSessionNewParams{
  	Agent:         juglow.BetaSessionNewParamsAgentUnion{OfString: juglow.String(agent.ID)},
  	EnvironmentID: environment.ID,
  	Metadata: map[string]string{
  		"input_file": "s3://my-bucket/data.csv",
  	},
  })
  if err != nil {
  	panic(err)
  }

  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .metadata(SessionCreateParams.Metadata.builder()
          .putAdditionalProperty("input_file", JsonValue.from("s3://my-bucket/data.csv"))
          .build())
      .build());

  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      metadata: ['input_file' => 's3://my-bucket/data.csv'],
  );

  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    metadata: {input_file: "s3://my-bucket/data.csv"}
  )

sudo mkdir -p /mnt/memory && sudo chown "$USER" /mnt/memory

  import asyncio
  import contextlib
  import os
  import signal
  from juglow import AsyncJuglow
  from juglow.lib.environments import EnvironmentWorker

  async def main() -> None:
      async with AsyncJuglow(auth_token=os.environ["JUGLOW_ENVIRONMENT_KEY"]) as client:
          worker = EnvironmentWorker(client, workdir="/workspace")
          # With no arguments, handle_item() reads the JUGLOW_* variables the spawn
          # script forwarded, including JUGLOW_WORK_SECRET.
          task = asyncio.create_task(worker.handle_item())
          # Cancelling the task when the container is stopped lets the worker upload
          # changed memory files and remove the store directories before it exits.
          loop = asyncio.get_running_loop()
          for signum in (signal.SIGINT, signal.SIGTERM):
              loop.add_signal_handler(signum, task.cancel)
          with contextlib.suppress(asyncio.CancelledError):
              await task

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";

  const client = new Juglow({ authToken: process.env.JUGLOW_ENVIRONMENT_KEY });
  const controller = new AbortController();
  // Aborting when the container is stopped lets the worker upload changed memory
  // files and remove the store directories before it exits.
  process.once("SIGTERM", () => controller.abort());
  process.once("SIGINT", () => controller.abort());

  // With no arguments, handleItem() reads the JUGLOW_* variables the spawn
  // script forwarded, including JUGLOW_WORK_SECRET.
  await new EnvironmentWorker({
    client,
    workdir: "/workspace",
    signal: controller.signal
  }).handleItem();

  // EnvironmentWorker is not currently available in the C# SDK.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  )

  func main() {
  	// Cancelling the context when the container is stopped lets the worker upload
  	// changed memory files and remove the store directories before it exits.
  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := juglow.NewClient(option.WithAuthToken(os.Getenv("JUGLOW_ENVIRONMENT_KEY")))
  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		Workdir: "/workspace",
  	})
  	// With zero-value options, HandleItem reads the JUGLOW_* variables the spawn
  	// script forwarded, including JUGLOW_WORK_SECRET.
  	if err := worker.HandleItem(ctx, environments.HandleItemOptions{}); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker is not currently available in the Java SDK.

  // EnvironmentWorker is not currently available in the PHP SDK.

  # EnvironmentWorker is not currently available in the Ruby SDK.

#!/bin/bash
# spawn.sh: called once per claimed work item
# The claimed work item arrives as JSON on stdin. Its secret is the
# per-session credential that the memory store endpoints require.
JUGLOW_WORK_SECRET="$(jq -r '.secret // empty')"
export JUGLOW_WORK_SECRET
mkdir -p "/host/outputs/$JUGLOW_SESSION_ID"
exec docker run --rm \
  -e JUGLOW_SESSION_ID -e JUGLOW_ENVIRONMENT_KEY \
  -e JUGLOW_WORK_ID -e JUGLOW_ENVIRONMENT_ID -e JUGLOW_BASE_URL \
  -e JUGLOW_WORK_SECRET \
  -v "/host/outputs/$JUGLOW_SESSION_ID":/workspace \
  your-sdk-worker-image

  worker = EnvironmentWorker(
      client,
      environment_id=environment_id,
      environment_key=environment_key,
      workdir="/workspace",
      memory_sync_interval=10,  # seconds
      memory_sync_deletions="log_only",
  )

  const worker = new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    memorySyncIntervalMs: 10_000,
    memorySyncDeletions: "log_only"
  });

  // EnvironmentWorker is not currently available in the C# SDK.

  worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  	EnvironmentID:       environmentID,
  	EnvironmentKey:      environmentKey,
  	Workdir:             "/workspace",
  	MemorySyncInterval:  10 * time.Second,
  	MemorySyncDeletions: environments.MemorySyncDeletionsLogOnly,
  })

  // EnvironmentWorker is not currently available in the Java SDK.

  // EnvironmentWorker is not currently available in the PHP SDK.

  # EnvironmentWorker is not currently available in the Ruby SDK.

{
  "type": "custom",
  "name": "get_order_status",
  "description": "Look up an order in the internal fulfillment system by order ID.",
  "input_schema": {
    "type": "object",
    "properties": {
      "order_id": { "type": "string", "description": "The order ID" }
    },
    "required": ["order_id"]
  }
}

  import asyncio
  import os
  from juglow import AsyncJuglow, beta_async_tool
  from juglow.lib.environments import EnvironmentWorker
  from juglow.lib.tools.agent_toolset import beta_agent_toolset_20260401

  @beta_async_tool
  async def get_order_status(order_id: str) -> str:
      """Look up an order in the internal fulfillment system by order ID."""
      # Runs on the worker host: call anything the sandbox can reach.
      return f"Order {order_id}: shipped"

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      async with AsyncJuglow(auth_token=environment_key) as client:
          await EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
              tools=lambda env: [*beta_agent_toolset_20260401(env), get_order_status],
          ).run()

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";
  import { betaTool } from "@juglow-ai/sdk/helpers/beta/json-schema";
  import { betaAgentToolset20260401 } from "@juglow-ai/sdk/tools/agent-toolset/node";

  const getOrderStatus = betaTool({
    name: "get_order_status",
    description: "Look up an order in the internal fulfillment system by order ID.",
    inputSchema: {
      type: "object",
      properties: { order_id: { type: "string", description: "The order ID" } },
      required: ["order_id"]
    },
    // Runs on the worker host: call anything the sandbox can reach.
    run: async ({ order_id }) => `Order ${order_id}: shipped`
  });

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });
  const controller = new AbortController();
  process.once("SIGTERM", () => controller.abort());

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal,
    tools: (ctx) => [...betaAgentToolset20260401(ctx), getOrderStatus]
  }).run();

  // EnvironmentWorker is not currently available in the C# SDK.
  // To answer custom tool calls directly, see the session event stream.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/toolrunner"
  	"github.com/juglows/juglow-sdk-go/tools/agenttoolset"
  )

  type orderStatusInput struct {
  	OrderID string `json:"order_id"`
  }

  func main() {
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	getOrderStatus := toolrunner.NewBetaTool(
  		"get_order_status",
  		"Look up an order in the internal fulfillment system by order ID.",
  		juglow.BetaToolInputSchemaParam{
  			Properties: map[string]any{
  				"order_id": map[string]any{"type": "string", "description": "The order ID"},
  			},
  			Required: []string{"order_id"},
  		},
  		// Runs on the worker host: call anything the sandbox can reach.
  		func(ctx context.Context, input orderStatusInput) (juglow.BetaToolResultBlockParamContentUnion, error) {
  			return juglow.BetaToolResultBlockParamContentUnion{
  				OfText: &juglow.BetaTextBlockParam{Text: "Order " + input.OrderID + ": shipped"},
  			}, nil
  		},
  	)

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  		ToolsFunc: func(env *agenttoolset.AgentToolContext) []juglow.BetaTool {
  			return append(agenttoolset.BetaAgentToolset20260401(env), getOrderStatus)
  		},
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker is not currently available in the Java SDK.
  // To answer custom tool calls directly, see the session event stream.

  // EnvironmentWorker is not currently available in the PHP SDK.
  // To answer custom tool calls directly, see the session event stream.

  # EnvironmentWorker is not currently available in the Ruby SDK.
  # To answer custom tool calls directly, see the session event stream.

  import asyncio
  from typing import Any, cast
  from juglow import AsyncJuglow
  from juglow.types.beta import BetaManagedAgentsCustomToolParams
  from mcp import ClientSession, types
  # Requires mcp >= 1.24, which renamed streamablehttp_client to streamable_http_client.
  from mcp.client.streamable_http import streamable_http_client

  MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp"

  def to_custom_tool(tool: types.Tool) -> BetaManagedAgentsCustomToolParams:
      # The MCP fields map one to one onto a custom tool declaration. The cast
      # hands the schema dictionary to the SDK's typed parameter unchanged.
      return {
          "type": "custom",
          "name": tool.name,
          "description": tool.description or tool.name,
          "input_schema": cast(Any, tool.inputSchema),
      }

  async def main() -> None:
      # Run this wherever you create agents, not on the worker host: it
      # authenticates with your Haijun API key (JUGLOW_API_KEY).
      async with (
          streamable_http_client(MCP_SERVER_URL) as (read, write, _),
          ClientSession(read, write) as mcp_session,
          AsyncJuglow() as client,
      ):
          await mcp_session.initialize()
          listed = await mcp_session.list_tools()
          agent = await client.beta.agents.create(
              name="Internal tools agent",
              model="haijun-opus-5-5",
              tools=[
                  {"type": "agent_toolset_20260401"},
                  *[to_custom_tool(tool) for tool in listed.tools],
              ],
          )
          print(agent.id)

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { Client } from "@modelcontextprotocol/sdk/client/index.js";
  import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

  const MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp";

  // Run this wherever you create agents, not on the worker host: it
  // authenticates with your Haijun API key (JUGLOW_API_KEY).
  const client = new Juglow();

  const mcpClient = new Client({ name: "declare-agent-tools", version: "1.0.0" });
  await mcpClient.connect(new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL)));
  const { tools } = await mcpClient.listTools();

  const agent = await client.beta.agents.create({
    name: "Internal tools agent",
    model: "haijun-opus-5-5",
    tools: [
      { type: "agent_toolset_20260401" },
      // The MCP fields map one to one onto a custom tool declaration.
      ...tools.map((tool) => ({
        type: "custom" as const,
        name: tool.name,
        description: tool.description || tool.name,
        input_schema: tool.inputSchema
      }))
    ]
  });
  console.log(agent.id);

  await mcpClient.close();

  // See the Python, TypeScript, and Go tabs. Declaring custom tools from
  // C# works the same way once you list the server's tools with an MCP client.

  package main

  import (
  	"context"
  	"encoding/json"
  	"fmt"
  	"log"

  	"github.com/juglows/juglow-sdk-go"
  	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
  )

  const mcpServerURL = "http://mcp.internal.example.com:8000/mcp"

  // toCustomTool maps one MCP tool definition onto a custom tool declaration.
  // The fields map one to one: the typed parameter carries `properties` and
  // `required`, and every other JSON Schema keyword the server emits travels in
  // ExtraFields so the declared schema matches the server's schema.
  func toCustomTool(tool *mcpsdk.Tool) (juglow.BetaAgentNewParamsToolUnion, error) {
  	raw, err := json.Marshal(tool.InputSchema)
  	if err != nil {
  		return juglow.BetaAgentNewParamsToolUnion{}, err
  	}
  	var schema map[string]any
  	if err := json.Unmarshal(raw, &schema); err != nil {
  		return juglow.BetaAgentNewParamsToolUnion{}, err
  	}

  	inputSchema := juglow.BetaManagedAgentsCustomToolInputSchemaParam{ExtraFields: map[string]any{}}
  	for keyword, value := range schema {
  		switch keyword {
  		case "type":
  			// The parameter type always marshals "type": "object".
  		case "properties":
  			properties, _ := value.(map[string]any)
  			inputSchema.Properties = properties
  		case "required":
  			entries, _ := value.([]any)
  			for _, entry := range entries {
  				if name, isString := entry.(string); isString {
  					inputSchema.Required = append(inputSchema.Required, name)
  				}
  			}
  		default:
  			inputSchema.ExtraFields[keyword] = value
  		}
  	}

  	description := tool.Description
  	if description == "" {
  		description = tool.Name
  	}
  	return juglow.BetaAgentNewParamsToolUnion{
  		OfCustom: &juglow.BetaManagedAgentsCustomToolParams{
  			Type:        juglow.BetaManagedAgentsCustomToolParamsTypeCustom,
  			Name:        tool.Name,
  			Description: description,
  			InputSchema: inputSchema,
  		},
  	}, nil
  }

  func main() {
  	ctx := context.Background()

  	// Run this wherever you create agents, not on the worker host: it
  	// authenticates with your Haijun API key (JUGLOW_API_KEY).
  	client := juglow.NewClient()

  	mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "declare-agent-tools", Version: "1.0.0"}, nil)
  	session, err := mcpClient.Connect(ctx, &mcpsdk.StreamableClientTransport{Endpoint: mcpServerURL}, nil)
  	if err != nil {
  		log.Fatalf("connect to MCP server: %v", err)
  	}
  	defer session.Close()

  	listed, err := session.ListTools(ctx, nil)
  	if err != nil {
  		log.Fatalf("list MCP tools: %v", err)
  	}

  	tools := []juglow.BetaAgentNewParamsToolUnion{
  		{OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
  			Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
  		}},
  	}
  	for _, tool := range listed.Tools {
  		custom, err := toCustomTool(tool)
  		if err != nil {
  			log.Fatalf("convert MCP tool %s: %v", tool.Name, err)
  		}
  		tools = append(tools, custom)
  	}

  	agent, err := client.Beta.Agents.New(ctx, juglow.BetaAgentNewParams{
  		Name:  "Internal tools agent",
  		Model: juglow.BetaManagedAgentsModelConfigParams{ID: juglow.BetaManagedAgentsModelHaijunOpus5_5},
  		Tools: tools,
  	})
  	if err != nil {
  		log.Fatalf("create agent: %v", err)
  	}
  	fmt.Println(agent.ID)
  }

  // See the Python, TypeScript, and Go tabs. Declaring custom tools from
  // Java works the same way once you list the server's tools with an MCP client.

  // See the Python, TypeScript, and Go tabs. Declaring custom tools from
  // PHP works the same way once you list the server's tools with an MCP client.

  # See the Python, TypeScript, and Go tabs. Declaring custom tools from
  # Ruby works the same way once you list the server's tools with an MCP client.

  import asyncio
  import os
  from datetime import timedelta
  from juglow import AsyncJuglow
  from juglow.lib.environments import EnvironmentWorker
  from juglow.lib.tools.agent_toolset import beta_agent_toolset_20260401
  from juglow.lib.tools.mcp import async_mcp_tool
  from mcp import ClientSession
  # Requires mcp >= 1.24, which renamed streamablehttp_client to streamable_http_client.
  from mcp.client.streamable_http import streamable_http_client

  MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp"

  async def main() -> None:
      environment_key = os.environ["JUGLOW_ENVIRONMENT_KEY"]
      environment_id = os.environ["JUGLOW_ENVIRONMENT_ID"]
      # Connect to the MCP server once at startup and keep the session open for
      # the life of the worker. The timeout turns a hung tool call into an error
      # result instead of a stalled call.
      async with (
          streamable_http_client(MCP_SERVER_URL) as (read, write, _),
          ClientSession(read, write, read_timeout_seconds=timedelta(seconds=60)) as mcp_session,
          AsyncJuglow(auth_token=environment_key) as client,
      ):
          await mcp_session.initialize()
          listed = await mcp_session.list_tools()
          mcp_tools = [async_mcp_tool(tool, mcp_session) for tool in listed.tools]
          await EnvironmentWorker(
              client,
              environment_id=environment_id,
              environment_key=environment_key,
              workdir="/workspace",
              tools=lambda env: [*beta_agent_toolset_20260401(env), *mcp_tools],
          ).run()

  asyncio.run(main())

  import Juglow from "@juglow-ai/sdk";
  import { EnvironmentWorker } from "@juglow-ai/sdk/helpers/beta/environments";
  import {
    mcpTools,
    type MCPCallToolResultLike,
    type MCPClientLike
  } from "@juglow-ai/sdk/helpers/beta/mcp";
  import { betaAgentToolset20260401 } from "@juglow-ai/sdk/tools/agent-toolset/node";
  import { Client } from "@modelcontextprotocol/sdk/client/index.js";
  import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

  const MCP_SERVER_URL = "http://mcp.internal.example.com:8000/mcp";

  const environmentKey = process.env.JUGLOW_ENVIRONMENT_KEY!;
  const environmentId = process.env.JUGLOW_ENVIRONMENT_ID!;
  const client = new Juglow({ authToken: environmentKey });
  const controller = new AbortController();
  process.once("SIGTERM", () => controller.abort());

  // Connect to the MCP server once at startup and keep the connection open for
  // the life of the worker.
  const mcpClient = new Client({ name: "sandbox-worker", version: "1.0.0" });
  await mcpClient.connect(new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL)));
  const { tools } = await mcpClient.listTools();

  // The MCP SDK's callTool return type still includes a legacy result shape that
  // mcpTools does not accept; narrow it. Drop this once MCPClientLike widens.
  const mcpClientForTools: MCPClientLike = {
    callTool: (params) => mcpClient.callTool(params) as Promise<MCPCallToolResultLike>
  };

  await new EnvironmentWorker({
    client,
    environmentId,
    environmentKey,
    workdir: "/workspace",
    signal: controller.signal,
    tools: (ctx) => [...betaAgentToolset20260401(ctx), ...mcpTools(tools, mcpClientForTools)]
  }).run();

  // EnvironmentWorker is not currently available in the C# SDK.

  package main

  import (
  	"context"
  	"log"
  	"os"
  	"os/signal"
  	"syscall"

  	"github.com/juglows/juglow-sdk-go"
  	"github.com/juglows/juglow-sdk-go/lib/environments"
  	"github.com/juglows/juglow-sdk-go/mcp"
  	"github.com/juglows/juglow-sdk-go/option"
  	"github.com/juglows/juglow-sdk-go/tools/agenttoolset"
  	mcpsdk "github.com/modelcontextprotocol/go-sdk/mcp"
  )

  const mcpServerURL = "http://mcp.internal.example.com:8000/mcp"

  func main() {
  	environmentKey := os.Getenv("JUGLOW_ENVIRONMENT_KEY")
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
  	defer stop()

  	client := juglow.NewClient(option.WithAuthToken(environmentKey))

  	// Connect to the MCP server once at startup and keep the session open for
  	// the life of the worker.
  	mcpClient := mcpsdk.NewClient(&mcpsdk.Implementation{Name: "sandbox-worker", Version: "1.0.0"}, nil)
  	session, err := mcpClient.Connect(ctx, &mcpsdk.StreamableClientTransport{Endpoint: mcpServerURL}, nil)
  	if err != nil {
  		log.Fatalf("connect to MCP server: %v", err)
  	}
  	defer session.Close()

  	listed, err := session.ListTools(ctx, nil)
  	if err != nil {
  		log.Fatalf("list MCP tools: %v", err)
  	}
  	mcpTools, err := mcp.NewBetaTools(listed.Tools, session)
  	if err != nil {
  		log.Fatalf("convert MCP tools: %v", err)
  	}

  	worker := environments.NewEnvironmentWorker(client, environments.EnvironmentWorkerOptions{
  		EnvironmentID:  environmentID,
  		EnvironmentKey: environmentKey,
  		Workdir:        "/workspace",
  		ToolsFunc: func(env *agenttoolset.AgentToolContext) []juglow.BetaTool {
  			return append(agenttoolset.BetaAgentToolset20260401(env), mcpTools...)
  		},
  	})
  	if err := worker.Run(ctx); err != nil {
  		log.Fatalf("worker: %v", err)
  	}
  }

  // EnvironmentWorker is not currently available in the Java SDK.

  // EnvironmentWorker is not currently available in the PHP SDK.

  # EnvironmentWorker is not currently available in the Ruby SDK.

  curl -sS "https://haijun.my.id/v1/environments/$JUGLOW_ENVIRONMENT_ID/work/stats" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "juglow-version: 2023-06-01"

  ant beta:environments:work stats --environment-id "$JUGLOW_ENVIRONMENT_ID"

  import os

  import juglow

  client = juglow.Juglow()

  stats = client.beta.environments.work.stats(os.environ["JUGLOW_ENVIRONMENT_ID"])
  print(f"depth={stats.depth} pending={stats.pending}")

  import Juglow from "@juglow-ai/sdk";

  const client = new Juglow();

  const stats = await client.beta.environments.work.stats(process.env.JUGLOW_ENVIRONMENT_ID!);

  console.log(`depth=${stats.depth} pending=${stats.pending}`);

  using Juglow;

  var client = new JuglowClient();

  var environmentId = Environment.GetEnvironmentVariable("JUGLOW_ENVIRONMENT_ID")!;

  var stats = await client.Beta.Environments.Work.Stats(environmentId);

  Console.WriteLine($"depth={stats.Depth} pending={stats.Pending}");

  package main

  import (
  	"context"
  	"fmt"
  	"os"

  	"github.com/juglows/juglow-sdk-go"
  )

  func main() {
  	client := juglow.NewClient()
  	environmentID := os.Getenv("JUGLOW_ENVIRONMENT_ID")

  	stats, err := client.Beta.Environments.Work.Stats(
  		context.Background(),
  		environmentID,
  		juglow.BetaEnvironmentWorkStatsParams{},
  	)
  	if err != nil {
  		panic(err)
  	}

  	fmt.Printf("depth=%d pending=%d\n", stats.Depth, stats.Pending)
  }

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.beta.environments.work.BetaSelfHostedWorkQueueStats;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      BetaSelfHostedWorkQueueStats stats = client.beta()
          .environments()
          .work()
          .stats(System.getenv("JUGLOW_ENVIRONMENT_ID"));

      IO.println("depth=" + stats.depth() + " pending=" + stats.pending());
  }

  <?php

  use Juglow\Client;

  $client = new Client();

  $stats = $client->beta->environments->work->stats(getenv('JUGLOW_ENVIRONMENT_ID'));

  printf("depth=%d pending=%d\n", $stats->depth, $stats->pending);

  require "juglow"

  client = Juglow::Client.new

  stats = client.beta.environments.work.stats(ENV.fetch("JUGLOW_ENVIRONMENT_ID"))

  puts "depth=#{stats.depth} pending=#{stats.pending}"

{
  "type": "work_queue_stats",
  "depth": 0,
  "pending": 0,
  "oldest_queued_at": null,
  "workers_polling": 0
}

  curl -sS "https://haijun.my.id/v1/environments/$JUGLOW_ENVIRONMENT_ID/work/$JUGLOW_WORK_ID/stop" \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-beta: managed-agents-2026-04-01" \
    -H "juglow-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{}'

  ant beta:environments:work stop \
    --environment-id "$JUGLOW_ENVIRONMENT_ID" \
    --work-id "$JUGLOW_WORK_ID"

  import os

  import juglow

  client = juglow.Juglow()

  work = client.beta.environments.work.stop(
      os.environ["JUGLOW_WORK_ID"],
      environment_id=os.environ["JUGLOW_ENVIRONMENT_ID"],
  )
  print(work.state)

  import Juglow from "@juglow-ai/sdk";

  const client = new Juglow();

  const work = await client.beta.environments.work.stop(process.env.JUGLOW_WORK_ID!, {
    environment_id: process.env.JUGLOW_ENVIRONMENT_ID!
  });

  console.log(work.state);

  using Juglow;

  var client = new JuglowClient();

  var work = await client.Beta.Environments.Work.Stop(
      Environment.GetEnvironmentVariable("JUGLOW_WORK_ID")!,
      new()
      {
          EnvironmentID = Environment.GetEnvironmentVariable("JUGLOW_ENVIRONMENT_ID")!
      }
  );

  Console.WriteLine(work.State);

  package main

  import (
  	"context"
  	"fmt"
  	"os"

  	"github.com/juglows/juglow-sdk-go"
  )

  func main() {
  	client := juglow.NewClient()

  	work, err := client.Beta.Environments.Work.Stop(
  		context.Background(),
  		os.Getenv("JUGLOW_WORK_ID"),
  		juglow.BetaEnvironmentWorkStopParams{
  			EnvironmentID: os.Getenv("JUGLOW_ENVIRONMENT_ID"),
  		},
  	)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(work.State)
  }

  import com.juglow.client.JuglowClient;
  import com.juglow.client.okhttp.JuglowOkHttpClient;
  import com.juglow.models.beta.environments.work.BetaSelfHostedWork;
  import com.juglow.models.beta.environments.work.BetaSelfHostedWorkStopRequest;
  import com.juglow.models.beta.environments.work.WorkStopParams;

  void main() {
      JuglowClient client = JuglowOkHttpClient.fromEnv();

      BetaSelfHostedWork work = client.beta().environments().work().stop(
          WorkStopParams.builder()
              .environmentId(System.getenv("JUGLOW_ENVIRONMENT_ID"))
              .workId(System.getenv("JUGLOW_WORK_ID"))
              .betaSelfHostedWorkStopRequest(BetaSelfHostedWorkStopRequest.builder().build())
              .build()
      );

      IO.println(work.state());
  }

  <?php

  use Juglow\Client;

  $client = new Client();

  $work = $client->beta->environments->work->stop(
      getenv('JUGLOW_WORK_ID'),
      environmentID: getenv('JUGLOW_ENVIRONMENT_ID'),
  );

  echo $work->state . "\n";

  require "juglow"

  client = Juglow::Client.new

  work = client.beta.environments.work.stop(
    ENV.fetch("JUGLOW_WORK_ID"),
    environment_id: ENV.fetch("JUGLOW_ENVIRONMENT_ID")
  )

  puts work.state