Managed Agents

Panduan ini memandu Anda dalam membuat agen, menyiapkan environment, memulai sesi, dan melakukan streaming respons agen.

Tip: Lebih suka panduan interaktif? Jalankan /haijun-api managed-agents-onboard di versi terbaru Haijun Code untuk penyiapan terpandu dan tanya jawab interaktif.

Konsep inti

Konsep	Deskripsi
Agent	Model, prompt sistem, alat, server MCP, dan track
Environment	Konfigurasi untuk tempat sesi berjalan: sandbox cloud yang dikelola Juglow, atau sandbox yang di-hosting sendiri di infrastruktur Anda sendiri
Session	Instans agen yang sedang berjalan di dalam sebuah environment, melakukan tugas tertentu dan menghasilkan output
Events	Pesan yang dipertukarkan antara aplikasi Anda dan agen (giliran pengguna, hasil alat, pembaruan status)

Prasyarat

Sebuah akun Haijun Console

Sebuah kunci API

Instal CLI

Homebrew (macOS)

bash

brew install juglows/tap/ant

curl (Linux/WSL)

Untuk environment Linux, unduh binary rilis secara langsung.

bash

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

Anda dapat menemukan semua rilis di halaman rilis GitHub.

Anda juga dapat menginstal CLI dari source menggunakan go install. Memerlukan Go 1.25 atau lebih baru.

bash

go install github.com/juglows/juglow-cli/cmd/ant@latest

Binary ditempatkan di $(go env GOPATH)/bin. Tambahkan ke PATH Anda jika belum ada:

bash

export PATH="$PATH:$(go env GOPATH)/bin"

Periksa instalasi:

bash

ant --version

Instal SDK

Python

bash

pip install juglow

TypeScript

bash

npm install @juglow-ai/sdk

Java

groovy

implementation("com.juglow:juglow-java:2.65.0")

bash

go get github.com/juglows/juglow-sdk-go

bash

dotnet add package Juglow

Ruby

bash

bundle add juglow

PHP

bash

composer require "juglow-ai/sdk" "guzzlehttp/guzzle:^7"

Atur kunci API Anda sebagai variabel environment:

bash

export JUGLOW_API_KEY="your-api-key-here"

Buat sesi pertama Anda

Buat agen

Buat agen yang mendefinisikan model, "system prompt" (prompt sistem), dan alat yang tersedia.

bash

    set -euo pipefail

    agent=$(
      curl -sS --fail-with-body https://haijun.my.id/v1/agents \
        -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'
    {
      "name": "Coding Assistant",
      "model": "haijun-opus-5-5",
      "system": "You are a helpful coding assistant. Write clean, well-documented code.",
      "tools": [
        {"type": "agent_toolset_20260401"}
      ]
    }
    EOF
    )

    AGENT_ID=$(jq -er '.id' <<<"$agent")
    AGENT_VERSION=$(jq -er '.version' <<<"$agent")

    echo "Agent ID: $AGENT_ID, version: $AGENT_VERSION"

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

bash

    ant apply coding-assistant.md

markdown

      ---
      name: Coding Assistant
      model: haijun-opus-5-5
      tools:
        - type: agent_toolset_20260401
      ---

      You are a helpful coding assistant. Write clean, well-documented code.

ant apply mencetak ID agen dan mencatatnya di haijun-lock.json. Anda akan mereferensikannya di setiap sesi yang Anda buat.

python

    from juglow import Juglow

    client = Juglow()

    agent = client.beta.agents.create(
        name="Coding Assistant",
        model="haijun-opus-5-5",
        system="You are a helpful coding assistant. Write clean, well-documented code.",
        tools=[
            {"type": "agent_toolset_20260401"},
        ],
    )

    print(f"Agent ID: {agent.id}, version: {agent.version}")

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

typescript

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

    const client = new Juglow();

    const agent = await client.beta.agents.create({
      name: "Coding Assistant",
      model: "haijun-opus-5-5",
      system: "You are a helpful coding assistant. Write clean, well-documented code.",
      tools: [
        { type: "agent_toolset_20260401" },
      ],
    });

    console.log(`Agent ID: ${agent.id}, version: ${agent.version}`);

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

csharp

    using Juglow;
    using Juglow.Models.Beta.Agents;
    using Juglow.Models.Beta.Environments;
    using Juglow.Models.Beta.Sessions;
    using Juglow.Models.Beta.Sessions.Events;

    var client = new JuglowClient();

    var agent = await client.Beta.Agents.Create(new()
    {
        Name = "Coding Assistant",
        Model = BetaManagedAgentsModel.HaijunOpus5_5,
        System = "You are a helpful coding assistant. Write clean, well-documented code.",
        Tools =
        [
            new BetaManagedAgentsAgentToolset20260401Params
            {
                Type = "agent_toolset_20260401",
            },
        ],
    });

    Console.WriteLine($"Agent ID: {agent.ID}, version: {agent.Version}");

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

    package main

    import (
    	"context"
    	"fmt"

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

    func main() {
    	client := juglow.NewClient()
    	ctx := context.Background()

    	agent, err := client.Beta.Agents.New(ctx, juglow.BetaAgentNewParams{
    		Name: "Coding Assistant",
    		Model: juglow.BetaManagedAgentsModelConfigParams{
    			ID: juglow.BetaManagedAgentsModelHaijunOpus5_5,
    		},
    		System: juglow.String("You are a helpful coding assistant. Write clean, well-documented code."),
    		Tools: []juglow.BetaAgentNewParamsToolUnion{{
    			OfAgentToolset20260401: &juglow.BetaManagedAgentsAgentToolset20260401Params{
    				Type: juglow.BetaManagedAgentsAgentToolset20260401ParamsTypeAgentToolset20260401,
    			},
    		}},
    	})
    	if err != nil {
    		panic(err)
    	}

    	fmt.Printf("Agent ID: %s, version: %d\n", agent.ID, agent.Version)

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

java

    import com.juglow.client.okhttp.JuglowOkHttpClient;
    import com.juglow.models.beta.agents.AgentCreateParams;
    import com.juglow.models.beta.agents.BetaManagedAgentsAgentToolset20260401Params;
    import com.juglow.models.beta.agents.BetaManagedAgentsModel;
    import com.juglow.models.beta.environments.BetaCloudConfigParams;
    import com.juglow.models.beta.environments.BetaUnrestrictedNetwork;
    import com.juglow.models.beta.environments.EnvironmentCreateParams;
    import com.juglow.models.beta.sessions.SessionCreateParams;
    import com.juglow.models.beta.sessions.events.BetaManagedAgentsStreamSessionEvents;
    import com.juglow.models.beta.sessions.events.BetaManagedAgentsUserMessageEventParams;
    import com.juglow.models.beta.sessions.events.EventSendParams;

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

        var agent = client.beta().agents().create(AgentCreateParams.builder()
            .name("Coding Assistant")
            .model(BetaManagedAgentsModel.HAIJUN_OPUS_5_5)
            .system("You are a helpful coding assistant. Write clean, well-documented code.")
            .addTool(BetaManagedAgentsAgentToolset20260401Params.builder()
                .type(BetaManagedAgentsAgentToolset20260401Params.Type.AGENT_TOOLSET_20260401)
                .build())
            .build());

        IO.println("Agent ID: " + agent.id() + ", version: " + agent.version());

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

php

    use Juglow\Client;

    $client = new Client();

    $agent = $client->beta->agents->create(
        name: 'Coding Assistant',
        model: 'haijun-opus-5-5',
        system: 'You are a helpful coding assistant. Write clean, well-documented code.',
        tools: [
            ['type' => 'agent_toolset_20260401'],
        ],
    );

    echo "Agent ID: {$agent->id}, version: {$agent->version}\n";

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

ruby

    require "juglow"

    client = Juglow::Client.new

    agent = client.beta.agents.create(
      name: "Coding Assistant",
      model: "haijun-opus-5-5",
      system_: "You are a helpful coding assistant. Write clean, well-documented code.",
      tools: [{type: "agent_toolset_20260401"}]
    )

    puts "Agent ID: #{agent.id}, version: #{agent.version}"

Simpan agent.id yang dikembalikan. Anda akan mereferensikannya di setiap sesi yang Anda buat.

Tipe alat agent_toolset_20260401 mengaktifkan set lengkap alat agen bawaan (bash, operasi file, pencarian web, dan lainnya). Lihat Alat untuk daftar lengkap dan opsi konfigurasi per alat.

Buat environment

Environment mendefinisikan sandbox tempat agen Anda berjalan.

bash

    environment=$(
      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 @- <<'EOF'
    {
      "name": "quickstart-env",
      "config": {
        "type": "cloud",
        "networking": {"type": "unrestricted"}
      }
    }
    EOF
    )

    ENVIRONMENT_ID=$(jq -er '.id' <<<"$environment")

    echo "Environment ID: $ENVIRONMENT_ID"

Simpan juga environment.id yang dikembalikan.

bash

    ant apply environment.yaml

yaml

      # yaml-language-server: $schema=https://platform.juglow.my.id/schemas/ant/beta/environment.json
      name: quickstart-env
      config:
        type: cloud
        networking:
          type: unrestricted

ant apply juga mencatat ID environment di haijun-lock.json. Untuk membuat agen dan environment dengan satu perintah, berikan kedua file: ant apply coding-assistant.md environment.yaml.

python

    environment = client.beta.environments.create(
        name="quickstart-env",
        config={
            "type": "cloud",
            "networking": {"type": "unrestricted"},
        },
    )

    print(f"Environment ID: {environment.id}")

Simpan juga environment.id yang dikembalikan.

typescript

    const environment = await client.beta.environments.create({
      name: "quickstart-env",
      config: {
        type: "cloud",
        networking: { type: "unrestricted" },
      },
    });

    console.log(`Environment ID: ${environment.id}`);

Simpan juga environment.id yang dikembalikan.

csharp

    var environment = await client.Beta.Environments.Create(new()
    {
        Name = "quickstart-env",
        Config = new BetaCloudConfigParams { Networking = new BetaUnrestrictedNetwork() },
    });

    Console.WriteLine($"Environment ID: {environment.ID}");

Simpan juga environment.id yang dikembalikan.

    environment, err := client.Beta.Environments.New(ctx, juglow.BetaEnvironmentNewParams{
    	Name: "quickstart-env",
    	Config: juglow.BetaEnvironmentNewParamsConfigUnion{
    		OfCloud: &juglow.BetaCloudConfigParams{
    			Networking: juglow.BetaCloudConfigParamsNetworkingUnion{
    				OfUnrestricted: &juglow.BetaUnrestrictedNetworkParam{},
    			},
    		},
    	},
    })
    if err != nil {
    	panic(err)
    }

    fmt.Printf("Environment ID: %s\n", environment.ID)

Simpan juga environment.id yang dikembalikan.

java

    var environment = client.beta().environments().create(EnvironmentCreateParams.builder()
        .name("quickstart-env")
        .config(BetaCloudConfigParams.builder()
            .networking(BetaUnrestrictedNetwork.builder().build())
            .build())
        .build());

    IO.println("Environment ID: " + environment.id());

Simpan juga environment.id yang dikembalikan.

php

    $environment = $client->beta->environments->create(
        name: 'quickstart-env',
        config: ['type' => 'cloud', 'networking' => ['type' => 'unrestricted']],
    );

    echo "Environment ID: {$environment->id}\n";

Simpan juga environment.id yang dikembalikan.

ruby

    environment = client.beta.environments.create(
      name: "quickstart-env",
      config: {type: "cloud", networking: {type: "unrestricted"}}
    )

    puts "Environment ID: #{environment.id}"

Simpan juga environment.id yang dikembalikan.

Tip: Untuk menjalankan sandbox di infrastruktur Anda sendiri alih-alih sandbox cloud, lihat Sandbox self-hosted .

Mulai sesi

Buat sesi yang mereferensikan agen dan environment Anda.

bash

  session=$(
    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": "$ENVIRONMENT_ID",
    "title": "Quickstart session"
  }
  EOF
  )

  SESSION_ID=$(jq -er '.id' <<<"$session")

  echo "Session ID: $SESSION_ID"

bash

  SESSION_ID=$(ant beta:sessions create \
    --agent "$AGENT_ID" \
    --environment-id "$ENVIRONMENT_ID" \
    --title "Quickstart session" \
    --transform id --raw-output)

  echo "Session ID: $SESSION_ID"

python

  session = client.beta.sessions.create(
      agent=agent.id,
      environment_id=environment.id,
      title="Quickstart session",
  )

  print(f"Session ID: {session.id}")

typescript

  const session = await client.beta.sessions.create({
    agent: agent.id,
    environment_id: environment.id,
    title: "Quickstart session",
  });

  console.log(`Session ID: ${session.id}`);

csharp

  var session = await client.Beta.Sessions.Create(new()
  {
      Agent = agent.ID,
      EnvironmentID = environment.ID,
      Title = "Quickstart session",
  });

  Console.WriteLine($"Session ID: {session.ID}");

  session, err := client.Beta.Sessions.New(ctx, juglow.BetaSessionNewParams{
  	Agent:         juglow.BetaSessionNewParamsAgentUnion{OfString: juglow.String(agent.ID)},
  	EnvironmentID: environment.ID,
  	Title:         juglow.String("Quickstart session"),
  })
  if err != nil {
  	panic(err)
  }

  fmt.Printf("Session ID: %s\n", session.ID)

java

  var session = client.beta().sessions().create(SessionCreateParams.builder()
      .agent(agent.id())
      .environmentId(environment.id())
      .title("Quickstart session")
      .build());

  IO.println("Session ID: " + session.id());

php

  $session = $client->beta->sessions->create(
      agent: $agent->id,
      environmentID: $environment->id,
      title: 'Quickstart session',
  );

  echo "Session ID: {$session->id}\n";

ruby

  session = client.beta.sessions.create(
    agent: agent.id,
    environment_id: environment.id,
    title: "Quickstart session"
  )

  puts "Session ID: #{session.id}"

Kirim pesan dan lakukan streaming respons

Buka stream, kirim event pengguna, lalu proses event saat tiba:

bash

  # Alur kerja ini tidak cocok diterjemahkan menjadi perintah shell sekali jalan.
  # Gunakan salah satu contoh SDK dalam grup kode ini sebagai gantinya.

bash

  # Alur kerja ini tidak cocok diterjemahkan menjadi perintah shell sekali jalan.
  # Sebagai gantinya, gunakan salah satu contoh SDK di grup kode ini.

python

  with client.beta.sessions.events.stream(session.id) as stream:
      # Kirim pesan pengguna setelah stream terbuka
      client.beta.sessions.events.send(
          session.id,
          events=[
              {
                  "type": "user.message",
                  "content": [
                      {
                          "type": "text",
                          "text": "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                      },
                  ],
              },
          ],
      )

      # Proses event streaming
      for event in stream:
          match event.type:
              case "agent.message":
                  for block in event.content:
                      if block.type == "text":
                          print(block.text, end="")
              case "agent.tool_use":
                  print(f"\n[Using tool: {event.name}]")
              case "session.status_idle":
                  print("\n\nAgent finished.")
                  break

typescript

  const stream = await client.beta.sessions.events.stream(session.id);

  // Kirim pesan pengguna setelah stream terbuka
  await client.beta.sessions.events.send(session.id, {
    events: [
      {
        type: "user.message",
        content: [
          {
            type: "text",
            text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
          },
        ],
      },
    ],
  });

  // Proses event streaming
  loop: for await (const event of stream) {
    switch (event.type) {
      case "agent.message":
        for (const block of event.content) {
          if (block.type === "text") {
            process.stdout.write(block.text);
          }
        }
        break;
      case "agent.tool_use":
        console.log(`\n[Using tool: ${event.name}]`);
        break;
      case "session.status_idle":
        console.log("\n\nAgent finished.");
        break loop;
    }
  }

csharp

  var stream = client.Beta.Sessions.Events.StreamStreaming(session.ID);

  // Kirim pesan pengguna setelah stream terbuka
  await client.Beta.Sessions.Events.Send(session.ID, new()
  {
      Events =
      [
          new BetaManagedAgentsUserMessageEventParams
          {
              Type = "user.message",
              Content =
              [
                  new BetaManagedAgentsTextBlock
                  {
                      Type = "text",
                      Text = "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
                  },
              ],
          },
      ],
  });

  // Proses event streaming
  await foreach (var ev in stream)
  {
      if (ev.Value is BetaManagedAgentsAgentMessageEvent message)
      {
          foreach (var block in message.Content)
          {
              if (block.Value is BetaManagedAgentsTextBlock textBlock)
              {
                  Console.Write(textBlock.Text);
              }
          }
      }
      else if (ev.Value is BetaManagedAgentsAgentToolUseEvent toolUse)
      {
          Console.WriteLine($"\n[Using tool: {toolUse.Name}]");
      }
      else if (ev.Value is BetaManagedAgentsSessionStatusIdleEvent)
      {
          Console.WriteLine("\n\nAgent finished.");
          break;
      }
  }

  	stream := client.Beta.Sessions.Events.StreamEvents(ctx, session.ID, juglow.BetaSessionEventStreamParams{})
  	defer stream.Close()

  	// Kirim pesan pengguna setelah stream terbuka
  	_, err = client.Beta.Sessions.Events.Send(ctx, session.ID, juglow.BetaSessionEventSendParams{
  		Events: []juglow.BetaManagedAgentsEventParamsUnion{{
  			OfUserMessage: &juglow.BetaManagedAgentsUserMessageEventParams{
  				Type: juglow.BetaManagedAgentsUserMessageEventParamsTypeUserMessage,
  				Content: []juglow.BetaManagedAgentsUserMessageEventParamsContentUnion{{
  					OfText: &juglow.BetaManagedAgentsTextBlockParam{
  						Type: juglow.BetaManagedAgentsTextBlockTypeText,
  						Text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt",
  					},
  				}},
  			},
  		}},
  	})
  	if err != nil {
  		panic(err)
  	}

  	// Proses event streaming
  loop:
  	for stream.Next() {
  		switch event := stream.Current().AsAny().(type) {
  		case juglow.BetaManagedAgentsAgentMessageEvent:
  			for _, block := range event.Content {
  				if block.Type == "text" {
  					fmt.Print(block.Text)
  				}
  			}
  		case juglow.BetaManagedAgentsAgentToolUseEvent:
  			fmt.Printf("\n[Using tool: %s]\n", event.Name)
  		case juglow.BetaManagedAgentsSessionStatusIdleEvent:
  			fmt.Print("\n\nAgent finished.\n")
  			break loop
  		}
  	}
  	if err := stream.Err(); err != nil {
  		panic(err)
  	}

java

  try (var stream = client.beta().sessions().events().streamStreaming(session.id())) {
      // Kirim pesan pengguna setelah stream terbuka
      client.beta().sessions().events().send(session.id(), EventSendParams.builder()
          .addEvent(BetaManagedAgentsUserMessageEventParams.builder()
              .type(BetaManagedAgentsUserMessageEventParams.Type.USER_MESSAGE)
              .addTextContent("Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt")
              .build())
          .build());

      // Proses event streaming
      loop:
      for (var event : (Iterable<BetaManagedAgentsStreamSessionEvents>) stream.stream()::iterator) {
          switch (event.type().value()) {
              case AGENT_MESSAGE -> event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
              case AGENT_TOOL_USE -> IO.println("\n[Using tool: " + event.asAgentToolUse().name() + "]");
              case SESSION_STATUS_IDLE -> {
                  IO.println("\n\nAgent finished.");
                  break loop;
              }
          }
      }
  }

php

  $stream = $client->beta->sessions->events->streamStream($session->id);

  // Kirim pesan pengguna setelah stream terbuka
  $client->beta->sessions->events->send(
      $session->id,
      events: [
          [
              'type' => 'user.message',
              'content' => [
                  ['type' => 'text', 'text' => 'Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt'],
              ],
          ],
      ],
  );

  // Proses event streaming
  foreach ($stream as $event) {
      match (true) {
          $event instanceof \Juglow\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent => array_walk(
              $event->content,
              static fn ($block) => $block instanceof \Juglow\Beta\Sessions\Events\ManagedAgentsTextBlock ? print($block->text) : null,
          ),
          $event instanceof \Juglow\Beta\Sessions\Events\ManagedAgentsAgentToolUseEvent => print("\n[Using tool: {$event->name}]\n"),
          $event instanceof \Juglow\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent => print("\n\nAgent finished.\n"),
          default => null,
      };
      if ($event->type === 'session.status_idle') {
          break;
      }
  }

ruby

  stream = client.beta.sessions.events.stream_events(session.id)

  # Kirim pesan pengguna setelah stream terbuka
  client.beta.sessions.events.send_(
    session.id,
    events: [{
      type: "user.message",
      content: [{type: "text", text: "Create a Python script that generates the first 20 Fibonacci numbers and saves them to fibonacci.txt"}]
    }]
  )

  # Proses event streaming
  stream.each do |event|
    case event
    when Juglow::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
      event.content.each { print it.text if it.is_a?(Juglow::Beta::Sessions::BetaManagedAgentsTextBlock) }
    when Juglow::Beta::Sessions::BetaManagedAgentsAgentToolUseEvent
      puts "\n[Using tool: #{event.name}]"
    when Juglow::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
      puts "\n\nAgent finished."
      break
    else
      # abaikan tipe event lainnya
    end
  end

Agen menulis skrip Python, menjalankannya di sandbox, dan memverifikasi bahwa file output telah dibuat. Output Anda akan terlihat mirip seperti ini:

text

I'll create a Python script that generates the first 20 Fibonacci numbers and saves them to a file.
[Using tool: write]
[Using tool: bash]
The script ran successfully. Let me verify the output file.
[Using tool: bash]
fibonacci.txt contains the first 20 Fibonacci numbers (0 through 4181).

Agent finished.

Apa yang terjadi

Saat Anda mengirim event pengguna, Haijun Managed Agents:

Menyediakan sandbox: Konfigurasi environment Anda menentukan bagaimana sandbox dibangun.

Menjalankan loop agen: Haijun menentukan alat mana yang akan digunakan berdasarkan pesan Anda.

Menjalankan alat: Penulisan file, perintah bash, dan pemanggilan alat lainnya berjalan di dalam sandbox.

Melakukan streaming event: Anda menerima pembaruan real-time saat agen bekerja.

Menjadi idle: Agen mengeluarkan event session.status_idle ketika tidak ada lagi yang perlu dilakukan.

Bangun aplikasi lengkap

Masing-masing quickstart ini memadukan Haijun Managed Agents dengan framework chat populer untuk membuat aplikasi lengkap yang dapat dijalankan. Di setiap quickstart, framework merender antarmuka chat sementara sesi terkelola menjalankan loop agen di sisi server: sesi menyimpan transkrip, menjalankan alat di sandbox, dan melakukan streaming event yang dirender oleh front end.

Analis riset dalam chat browser yang dibangun dengan Chat SDK dari Vercel. Setiap percakapan adalah satu sesi persisten yang melakukan streaming balasannya sementara feed langsung menampilkan pemanggilan alat. Mengganti adapter Chat SDK memindahkan handler yang sama ke Slack, Teams, Discord, atau WhatsApp.

Analis spreadsheet dalam chat yang dibangun dari primitif assistant-ui. Sesi menjadi daftar thread, satu reducer mengubah log event sesi menjadi pesan dan kartu alat, dan setiap perintah bash merender gerbang Allow/Deny inline sebelum dijalankan.

Asisten keuangan pribadi dalam chat CopilotKit. Adapter AG-UI untuk Haijun Managed Agents memetakan setiap thread chat ke sesi terkelola dan melakukan streaming balasan token demi token, dan alat kustom merender grafik interaktif secara inline dalam percakapan.

Langkah selanjutnya

Buat konfigurasi agen yang dapat digunakan ulang dan memiliki versi

Sesuaikan pengaturan jaringan dan sandbox

Aktifkan alat tertentu untuk agen Anda

Tangani event dan arahkan agen di tengah eksekusi

Jalankan agen Anda pada jadwal cron berulang

Saring korpus dokumen sekali menjadi wiki pengetahuan, lalu jawab pertanyaan berulang darinya dengan biaya yang jauh lebih kecil

#Konsep inti

#Prasyarat

#Instal CLI

#Instal SDK

#Buat sesi pertama Anda

#Apa yang terjadi

#Bangun aplikasi lengkap

#Langkah selanjutnya

Konsep inti

Prasyarat

Instal CLI

Instal SDK

Buat sesi pertama Anda

Apa yang terjadi

Bangun aplikasi lengkap

Langkah selanjutnya