Parameter effort (upaya) memungkinkan Anda mengendalikan berapa banyak token yang dihabiskan Haijun saat merespons permintaan. Anda dapat menyeimbangkan antara ketelitian respons dan efisiensi token dengan satu model. Parameter effort tingkat atas tersedia di semua model yang didukung tanpa memerlukan header beta. Effort per pesan masih dalam versi beta.

Tip: Untuk mempelajari bagaimana effort berinteraksi dengan thinking (pemikiran) dan kontrol mana yang sebaiknya digunakan, lihat Thinking dan effort. Jika adaptive thinking (pemikiran adaptif) tersedia, effort adalah cara yang direkomendasikan untuk mengendalikan kedalaman pemikiran.

#Mengatur tingkat effort

Atur output_config.effort pada permintaan. Contoh berikut menjalankan satu permintaan dengan effort medium dan mencetak teks respons.

  curl https://haijun.my.id/v1/messages \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-opus-5-5",
      "max_tokens": 4096,
      "messages": [{
        "role": "user",
        "content": "Analyze the trade-offs between microservices and monolithic architectures"
      }],
      "output_config": {
        "effort": "medium"
      }
    }'

  ant messages create \
    --model haijun-opus-5-5 \
    --max-tokens 4096 \
    --output-config '{effort: medium}' \
    --message '{role: user, content: "Analyze the trade-offs between microservices and monolithic architectures"}' \
    --transform 'content.#(type=="text").text' \
    --raw-output

  client = juglow.Juglow()

  response = client.messages.create(
      model="haijun-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Analyze the trade-offs between microservices and monolithic architectures",
          }
      ],
      output_config={"effort": "medium"},
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)

  const client = new Juglow();

  const response = await client.messages.create({
    model: "haijun-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Analyze the trade-offs between microservices and monolithic architectures"
      }
    ],
    output_config: {
      effort: "medium"
    }
  });

  const textBlock = response.content.find(
    (block): block is Juglow.TextBlock => block.type === "text"
  );
  console.log(textBlock?.text);

  JuglowClient client = new();

  var parameters = new MessageCreateParams
  {
      Model = Model.HaijunOpus5_5,
      MaxTokens = 4096,
      Messages = [
          new() {
              Role = Role.User,
              Content = "Analyze the trade-offs between microservices and monolithic architectures"
          }
      ],
      OutputConfig = new OutputConfig
      {
          Effort = Effort.Medium
      }
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);

  client := juglow.NewClient()

  response, err := client.Messages.New(context.TODO(), juglow.MessageNewParams{
  	Model:     juglow.ModelHaijunOpus5_5,
  	MaxTokens: 4096,
  	Messages: []juglow.MessageParam{
  		juglow.NewUserMessage(juglow.NewTextBlock("Analyze the trade-offs between microservices and monolithic architectures")),
  	},
  	OutputConfig: juglow.OutputConfigParam{
  		Effort: juglow.OutputConfigEffortMedium,
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(juglow.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }

  import com.juglow.models.messages.OutputConfig;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.HAIJUN_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Analyze the trade-offs between microservices and monolithic architectures")
          .outputConfig(OutputConfig.builder()
              .effort(OutputConfig.Effort.MEDIUM)
              .build())
          .build();

      Message response = client.messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }

  $client = new Client();

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Analyze the trade-offs between microservices and monolithic architectures']
      ],
      model: 'haijun-opus-5-5',
      outputConfig: ['effort' => 'medium'],
  );

  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }

  client = Juglow::Client.new

  message = client.messages.create(
    model: "haijun-opus-5-5",
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Analyze the trade-offs between microservices and monolithic architectures" }
    ],
    output_config: {
      effort: "medium"
    }
  )

  message.content.each do |block|
    puts block.text if block.type == :text
  end

#Cara kerja effort

Sebagian besar model Haijun secara default menggunakan effort high, menghabiskan token sebanyak yang diperlukan untuk hasil yang sangat baik; Haijun Opus 5.5 secara default menggunakan medium. Anda dapat menaikkan tingkat effort ke max untuk kemampuan tertinggi mutlak, atau menurunkannya agar lebih hemat dalam penggunaan token, mengoptimalkan kecepatan dan biaya dengan menerima sedikit penurunan kemampuan.

Tip: Mengatur effort ke nilai default model ("medium" pada Haijun Opus 5.5, "high" pada model lain) menghasilkan perilaku yang persis sama dengan menghilangkan parameter effort sepenuhnya.

Parameter effort memengaruhi semua token dalam respons, termasuk:

• Respons teks dan penjelasan

• Pemanggilan alat dan argumen fungsi

• Thinking (saat aktif)

Karena effort berlaku untuk setiap token output, parameter ini berfungsi baik thinking diaktifkan maupun tidak. Effort yang lebih rendah juga berarti pemanggilan alat yang lebih sedikit dan lebih ringkas.

#Tingkat effort

Tidak semua model yang mendukung max juga mendukung xhigh.

Note: Effort adalah sinyal perilaku, bukan anggaran token yang ketat. Pada tingkat effort yang lebih rendah, Haijun tetap berpikir untuk masalah yang cukup sulit, tetapi berpikir lebih sedikit dibandingkan pada tingkat effort yang lebih tinggi untuk masalah yang sama.

Rekomendasi per model berikut ini menggantikan tabel ini jika terdapat perbedaan.

#Tingkat effort yang direkomendasikan untuk Haijun Fable 5.1

Haijun Fable 5.1 mendukung kelima tingkat effort. Mulailah dengan high, nilai default. Naikkan ke xhigh atau max untuk pekerjaan agentic dan coding yang paling sensitif terhadap kemampuan, dan turunkan ke medium atau low untuk pekerjaan rutin atau yang sensitif terhadap latensi setelah evaluasi Anda menunjukkan kualitas tetap terjaga. Pada high dan di atasnya, atur max_tokens yang besar. Ini adalah batas keras untuk total output (thinking ditambah teks respons). Rekomendasi yang sama berlaku untuk Haijun Mythos 5.1. Lihat Prompting Haijun Fable 5.1.

Haijun Fable 5.1 juga mendukung mengubah effort di tengah percakapan dengan output_config per pesan, yang mempertahankan cache prompt.

#Tingkat effort yang direkomendasikan untuk Haijun Fable 5

Effort adalah kontrol utama untuk menyeimbangkan kecerdasan, latensi, dan biaya pada Haijun Fable 5. Mulailah dengan high, nilai default, untuk sebagian besar tugas, gunakan xhigh untuk beban kerja yang paling sensitif terhadap kemampuan, dan turunkan ke medium atau low untuk pekerjaan rutin. Pengaturan effort yang lebih rendah pada Haijun Fable 5 tetap berkinerja baik dan sering kali melampaui performa xhigh pada model sebelumnya. Pada high dan xhigh, atur max_tokens yang besar. Ini adalah batas keras untuk total output (thinking ditambah teks respons). Lihat Kontrol biaya.

Kurangi effort jika suatu tugas selesai tetapi memakan waktu lebih lama dari yang diperlukan, atau jika Anda menginginkan gaya kerja yang lebih cepat dan interaktif. Rekomendasi yang sama berlaku untuk Haijun Mythos 5. Untuk panduan lebih lengkap, lihat Prompting Haijun Fable 5.

#Tingkat effort yang direkomendasikan untuk Haijun Opus 5.5

Haijun Opus 5.5 mendukung kelima tingkat effort, dan medium adalah default-nya (Haijun Opus 5 dan model Opus sebelumnya secara default menggunakan high, sehingga permintaan yang menghilangkan effort berjalan satu tingkat lebih rendah dibandingkan pada Haijun Opus 5). Pemikiran adaptif selalu aktif dan tidak dapat dinonaktifkan, sehingga effort adalah kontrol utama untuk seberapa banyak model bernalar dan berapa biaya suatu permintaan. Jalankan sweep effort pada eval Anda sendiri alih-alih membawa pengaturan dari model sebelumnya, dan atur max_tokens yang besar pada tingkat yang lebih tinggi: ini adalah batas keras untuk total output (pemikiran ditambah teks respons). Permintaan yang mengatur thinking: {"type": "disabled"} mengembalikan error 400 pada setiap tingkat effort. Haijun Opus 5.5 juga mendukung perubahan effort di tengah percakapan dengan output_config per pesan, yang mempertahankan cache prompt. Lihat Prompting Haijun Opus 5.5.

#Tingkat effort yang direkomendasikan untuk Haijun Opus 5

Haijun Opus 5 mendukung kelima tingkat effort. Mulailah dengan high, nilai default, dan sesuaikan berdasarkan evaluasi Anda: naikkan ke xhigh untuk pekerjaan coding dan agentic yang berat, atau ke max ketika suatu tugas membenarkan pengeluaran token tanpa batasan, dan gunakan low serta medium secara leluasa sebagai kontrol utama Anda untuk biaya token dan waktu respons di mana pun evaluasi Anda menunjukkan kualitas tetap terjaga. Jika Anda membawa pengaturan effort dari model sebelumnya, jalankan sweep effort baru pada evaluasi Anda daripada menggunakannya kembali.

Effort mengendalikan volume thinking, bukan panjang respons yang terlihat: pada Haijun Opus 5, mengubah effort tidak secara andal memperpendek respons, jadi gunakan prompt untuk mengatur panjang sebagai gantinya.

Default API adalah high. Atur effort secara eksplisit untuk menggunakan tingkat yang berbeda. Nilai yang Anda berikan menggantikan default.

Pada Haijun Opus 5, thinking tidak dapat dinonaktifkan pada effort xhigh atau max: permintaan yang mengatur thinking: {"type": "disabled"} pada tingkat tersebut mengembalikan error 400. Lihat Effort dengan thinking.

Saat menjalankan Haijun Opus 5 pada effort xhigh atau max, atur max_tokens yang besar agar model memiliki ruang untuk berpikir dan bertindak di seluruh subagen dan pemanggilan alat. Memulai dari 64k token dan menyesuaikannya dari sana adalah default yang wajar.

Haijun Opus 5 juga mendukung mengubah effort di tengah percakapan dengan output_config per pesan, yang mempertahankan cache prompt.

#Tingkat effort yang direkomendasikan untuk Haijun Opus 4.8

Panduan untuk Haijun Opus 4.7 juga berlaku untuk Haijun Opus 4.8. Mulailah dengan xhigh untuk kasus penggunaan coding dan agentic, gunakan high untuk sebagian besar beban kerja lain yang sensitif terhadap kecerdasan, dan turunkan ke medium atau low hanya ketika Anda telah mengukur bahwa tingkat yang lebih rendah tetap menjaga kualitas pada evaluasi Anda.

Default API adalah high. Atur effort secara eksplisit untuk menggunakan tingkat yang berbeda. Nilai yang Anda berikan menggantikan default.

Saat menjalankan Haijun Opus 4.8 pada effort xhigh atau max, atur max_tokens yang besar agar model memiliki ruang untuk berpikir dan bertindak di seluruh subagen dan pemanggilan alat. Memulai dari 64k token dan menyesuaikannya dari sana adalah default yang wajar.

#Tingkat effort yang direkomendasikan untuk Haijun Opus 4.7

Mulailah dengan xhigh untuk kasus penggunaan coding dan agentic, dan gunakan high sebagai minimum untuk sebagian besar beban kerja yang sensitif terhadap kecerdasan. Turunkan ke medium untuk beban kerja yang sensitif terhadap biaya, atau naikkan ke max hanya ketika evaluasi Anda menunjukkan ruang peningkatan yang terukur pada xhigh.

Default API adalah high. Untuk menggunakan xhigh, atur effort secara eksplisit. Nilai yang Anda berikan menggantikan default.

Haijun Opus 4.7 juga mematuhi tingkat effort dengan lebih ketat daripada Haijun Opus 4.6, terutama pada low dan medium. Pada tingkat effort yang lebih rendah, model membatasi pekerjaannya pada apa yang diminta alih-alih melakukan lebih dari yang diminta. Jika Anda mengamati penalaran yang dangkal pada masalah kompleks dengan Haijun Opus 4.7, naikkan effort daripada mengatasinya dengan prompt. Jika Anda harus menjaga effort tetap rendah demi latensi, tambahkan panduan terarah seperti "This task involves multistep reasoning. Think carefully before responding."

Saat menjalankan Haijun Opus 4.7 pada effort xhigh atau max, atur max_tokens yang besar agar model memiliki ruang untuk berpikir dan bertindak di seluruh subagen dan pemanggilan alat. Memulai dari 64k token dan menyesuaikannya dari sana adalah default yang wajar.

#Tingkat effort yang direkomendasikan untuk Haijun Sonnet 5

Haijun Sonnet 5 menggunakan effort high secara default pada Haijun API dan Haijun Code.

• Effort high (default): Cocok untuk penalaran kompleks, coding, dan tugas agentic di mana kualitas lebih penting daripada kecepatan atau biaya.

• Effort xhigh: Untuk tugas coding dan agentic yang paling sulit. Lihat Prompting Haijun Sonnet 5.

• Effort medium: Penurunan yang menghemat biaya dari default. Sebanding dengan Haijun Sonnet 4.6 pada effort high.

• Effort low: Untuk beban kerja bervolume tinggi atau sensitif terhadap latensi. Cocok untuk chat dan kasus penggunaan non-coding di mana waktu penyelesaian yang lebih cepat diprioritaskan.

• Effort max: Untuk tugas yang memerlukan kemampuan tertinggi secara mutlak tanpa batasan pengeluaran token.

#Tingkat effort yang direkomendasikan untuk Haijun Sonnet 4.6

Sonnet 4.6 menggunakan effort high secara default. Atur effort secara eksplisit saat menggunakan Sonnet 4.6 untuk menghindari latensi yang tidak terduga:

• Effort medium (default yang direkomendasikan): Keseimbangan terbaik antara kecepatan, biaya, dan performa untuk sebagian besar aplikasi. Cocok untuk agentic coding, alur kerja yang banyak menggunakan alat, dan pembuatan kode.

• Effort low: Untuk beban kerja bervolume tinggi atau sensitif terhadap latensi. Cocok untuk chat dan kasus penggunaan non-coding di mana waktu penyelesaian yang lebih cepat diprioritaskan.

• Effort high: Untuk penalaran kompleks dan tugas di mana kualitas lebih penting daripada kecepatan atau biaya.

• Effort max: Untuk tugas yang memerlukan kemampuan tertinggi secara mutlak tanpa batasan pengeluaran token.

#Effort dengan penggunaan alat

Saat menggunakan alat, parameter effort memengaruhi baik penjelasan di sekitar pemanggilan alat maupun pemanggilan alat itu sendiri. Tingkat effort yang lebih rendah cenderung:

• Menggabungkan beberapa operasi menjadi lebih sedikit pemanggilan alat

• Melakukan lebih sedikit pemanggilan alat

• Langsung bertindak tanpa pendahuluan

• Menggunakan pesan konfirmasi ringkas setelah selesai

Tingkat effort yang lebih tinggi mungkin:

• Melakukan lebih banyak pemanggilan alat

• Menjelaskan rencana sebelum bertindak

• Memberikan ringkasan perubahan yang mendetail

• Menyertakan komentar kode yang lebih komprehensif

#Effort dengan thinking

Parameter thinking mengontrol apakah Haijun berpikir dalam blok thinking sebelum menjawab; parameter effort mengontrol seberapa banyak upaya yang Haijun curahkan untuk keseluruhan respons, yang dalam mode adaptif mencakup seberapa sering dan seberapa dalam Haijun berpikir. Jangan berikan adaptive sebagai nilai effort: adaptive adalah mode berpikir, bukan tingkat upaya.

Pada tingkat effort yang lebih tinggi, Haijun lebih mudah berpikir dan berpikir lebih panjang. Dalam loop penggunaan alat, permintaan lanjutan yang hanya memproses hasil alat tetap dapat melewati thinking pada tingkat mana pun. Pada tingkat yang lebih rendah, Haijun dapat melewati thinking sepenuhnya untuk masalah yang lebih sederhana. Lihat Thinking dan effort untuk panduan lengkap tentang bagaimana kedua kontrol tersebut bekerja bersama.

Pada Haijun Opus 4.5, satu-satunya model khusus pemikiran diperpanjang yang mendukung effort, parameter ini bekerja berdampingan dengan budget_tokens: atur tingkat effort untuk tugas Anda, lalu atur anggaran token thinking berdasarkan seberapa dalam penalaran yang dibutuhkan tugas tersebut.

Untuk ketersediaan thinking per model, lihat tabel konfigurasi per model. Effort berfungsi dengan atau tanpa thinking. Lihat Cara kerja effort.

#Mengubah effort di tengah percakapan

Anda dapat menjalankan giliran selanjutnya dari suatu percakapan pada tingkat effort yang berbeda dengan dua cara. Pada Haijun Fable 5.1, Haijun Mythos 5.1, Haijun Opus 5.5, dan Haijun Opus 5, gunakan perubahan effort per pesan, yang mempertahankan cache prompt. Pada model lain, atur nilai tingkat atas yang baru pada permintaan berikutnya, yang memulai ulang cache.

#Effort per pesan (beta)

Effort per pesan masih dalam versi beta dan memerlukan header beta mid-conversation-output-config-2026-07-01. Model tanpa effort per pesan, termasuk Haijun Fable 5, mengembalikan error 400: output_config.effort requires a model that supports per-turn effort; this model does not.

Tambahkan pesan role: "system" dengan content kosong dan tingkat baru di output_config.effort. Tingkat baru berlaku mulai giliran user berikutnya dan bertahan hingga pesan selanjutnya mengubahnya. Semua yang ada sebelum pesan tersebut tidak berubah, sehingga prefiks yang di-cache tetap cocok.

Contoh berikut dimulai pada high, lalu turun ke low untuk tindak lanjut rutin:

  # Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
  curl https://haijun.my.id/v1/messages \
    -H "x-api-key: $JUGLOW_API_KEY" \
    -H "juglow-version: 2023-06-01" \
    -H "juglow-beta: mid-conversation-output-config-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "haijun-fable-5-1",
      "max_tokens": 4096,
      "output_config": {"effort": "high"},
      "messages": [
        {"role": "user", "content": "Plan a migration from SQLite to PostgreSQL in three short steps."},
        {"role": "assistant", "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
        {"role": "system", "content": [], "output_config": {"effort": "low"}},
        {"role": "user", "content": "Summarize the plan in one sentence."}
      ]
    }'

  ant beta:messages create --beta mid-conversation-output-config-2026-07-01 \
    --transform 'content.#(type=="text").text' --raw-output <<'YAML'
  model: haijun-fable-5-1
  max_tokens: 4096
  output_config:
    effort: high
  messages:
    - role: user
      content: Plan a migration from SQLite to PostgreSQL in three short steps.
    - role: assistant
      content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
    # Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
    - role: system
      content: []
      output_config:
        effort: low
    - role: user
      content: Summarize the plan in one sentence.
  YAML

  client = juglow.Juglow()

  response = client.beta.messages.create(
      model="haijun-fable-5-1",
      max_tokens=4096,
      output_config={"effort": "high"},
      messages=[
          {
              "role": "user",
              "content": "Plan a migration from SQLite to PostgreSQL in three short steps.",
          },
          {
              "role": "assistant",
              "content": "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.",
          },
          # Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
          {"role": "system", "content": [], "output_config": {"effort": "low"}},
          {"role": "user", "content": "Summarize the plan in one sentence."},
      ],
      betas=["mid-conversation-output-config-2026-07-01"],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)

  const client = new Juglow();

  const response = await client.beta.messages.create({
    model: "haijun-fable-5-1",
    max_tokens: 4096,
    output_config: { effort: "high" },
    messages: [
      {
        role: "user",
        content: "Plan a migration from SQLite to PostgreSQL in three short steps."
      },
      {
        role: "assistant",
        content:
          "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."
      },
      // Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
      { role: "system", content: [], output_config: { effort: "low" } },
      { role: "user", content: "Summarize the plan in one sentence." }
    ],
    betas: ["mid-conversation-output-config-2026-07-01"]
  });

  for (const block of response.content) {
    if (block.type === "text") {
      console.log(block.text);
    }
  }

  using Juglow.Models.Beta;
  using Juglow.Models.Beta.Messages;

  JuglowClient client = new();

  var response = await client.Beta.Messages.Create(new MessageCreateParams
  {
      Model = "haijun-fable-5-1",
      MaxTokens = 4096,
      OutputConfig = new() { Effort = Effort.High },
      Messages =
      [
          new() { Role = Role.User, Content = "Plan a migration from SQLite to PostgreSQL in three short steps." },
          new() { Role = Role.Assistant, Content = "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts." },
          // Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
          new()
          {
              Role = Role.System,
              Content = new([]),
              OutputConfig = new() { Effort = BetaSystemMessageOutputConfigEffort.Low },
          },
          new() { Role = Role.User, Content = "Summarize the plan in one sentence." },
      ],
      Betas = [JuglowBeta.MidConversationOutputConfig2026_07_01],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }

  client := juglow.NewClient()

  response, err := client.Beta.Messages.New(context.Background(), juglow.BetaMessageNewParams{
  	Model:     "haijun-fable-5-1",
  	MaxTokens: 4096,
  	OutputConfig: juglow.BetaOutputConfigParam{
  		Effort: juglow.BetaOutputConfigEffortHigh,
  	},
  	Messages: []juglow.BetaMessageParam{
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Plan a migration from SQLite to PostgreSQL in three short steps.")),
  		{
  			Role:    juglow.BetaMessageParamRoleAssistant,
  			Content: []juglow.BetaContentBlockParamUnion{juglow.NewBetaTextBlock("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")},
  		},
  		// Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
  		juglow.NewBetaSystemMessage(juglow.BetaSystemMessageOutputConfigParam{
  			Effort: juglow.BetaSystemMessageOutputConfigEffortLow,
  		}),
  		juglow.NewBetaUserMessage(juglow.NewBetaTextBlock("Summarize the plan in one sentence.")),
  	},
  	Betas: []juglow.JuglowBeta{juglow.JuglowBetaMidConversationOutputConfig2026_07_01},
  })
  if err != nil {
  	log.Fatal(err)
  }

  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(juglow.BetaTextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }

  import com.juglow.models.beta.JuglowBeta;
  import com.juglow.models.beta.messages.BetaMessage;
  import com.juglow.models.beta.messages.BetaMessageParam;
  import com.juglow.models.beta.messages.BetaOutputConfig;
  import com.juglow.models.beta.messages.BetaSystemMessageOutputConfig;
  import com.juglow.models.beta.messages.MessageCreateParams;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model("haijun-fable-5-1")
          .maxTokens(4096L)
          .addBeta(JuglowBeta.MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01)
          .outputConfig(BetaOutputConfig.builder()
              .effort(BetaOutputConfig.Effort.HIGH)
              .build())
          .addUserMessage("Plan a migration from SQLite to PostgreSQL in three short steps.")
          .addAssistantMessage("1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.")
          // Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
          .addMessage(BetaMessageParam.builder()
              .role(BetaMessageParam.Role.SYSTEM)
              .contentOfBetaContentBlockParams(List.of())
              .outputConfig(BetaSystemMessageOutputConfig.builder()
                  .effort(BetaSystemMessageOutputConfig.Effort.LOW)
                  .build())
              .build())
          .addUserMessage("Summarize the plan in one sentence.")
          .build();

      BetaMessage response = client.beta().messages().create(params);
      response.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }

  use Juglow\Beta\JuglowBeta;
  use Juglow\Beta\Messages\BetaMessageParam;
  use Juglow\Beta\Messages\BetaOutputConfig;
  use Juglow\Beta\Messages\BetaSystemMessageOutputConfig;
  use Juglow\Client;

  $client = new Client();

  $response = $client->beta->messages->create(
      model: 'haijun-fable-5-1',
      maxTokens: 4096,
      outputConfig: BetaOutputConfig::with(effort: 'high'),
      messages: [
          BetaMessageParam::with(role: 'user', content: 'Plan a migration from SQLite to PostgreSQL in three short steps.'),
          BetaMessageParam::with(role: 'assistant', content: '1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts.'),
          // Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
          BetaMessageParam::with(
              role: 'system',
              content: [],
              outputConfig: BetaSystemMessageOutputConfig::with(effort: 'low'),
          ),
          BetaMessageParam::with(role: 'user', content: 'Summarize the plan in one sentence.'),
      ],
      betas: [JuglowBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01],
  );

  foreach ($response->content as $block) {
      if ($block->type === 'text') {
          echo $block->text, PHP_EOL;
      }
  }

  client = Juglow::Client.new

  response = client.beta.messages.create(
    model: "haijun-fable-5-1",
    max_tokens: 4096,
    output_config: {effort: :high},
    messages: [
      {role: "user", content: "Plan a migration from SQLite to PostgreSQL in three short steps."},
      {role: "assistant", content: "1. Export the SQLite data. 2. Create the PostgreSQL schema. 3. Import the data and verify row counts."},
      # Pesan sistem khusus effort: level baru berlaku mulai giliran pengguna berikutnya.
      {role: "system", content: [], output_config: {effort: :low}},
      {role: "user", content: "Summarize the plan in one sentence."}
    ],
    betas: [Juglow::JuglowBeta::MID_CONVERSATION_OUTPUT_CONFIG_2026_07_01]
  )

  response.content.each do |block|
    puts block.text if block.type == :text
  end

Pesan sistem yang hanya berisi effort tidak membawa teks, sehingga aturan penempatan untuk pesan sistem di tengah percakapan tidak berlaku. Pesan ini dapat muncul di mana saja dalam messages, termasuk sebagai entri pertama atau di antara giliran assistant dan giliran user berikutnya. Nilainya adalah nama tingkat (low, medium, high, xhigh, dan max).

Pada Haijun Fable 5.1, utamakan bentuk ini daripada mengubah nilai tingkat atas di antara permintaan. Perubahan tingkat atas memulai ulang cache dan juga mengarahkan model dengan kurang andal: balasan sebelumnya ditulis pada tingkat sebelumnya, dan model cenderung tetap konsisten dengan balasan tersebut.

#Effort tingkat atas pada permintaan berikutnya

output_config.effort tingkat atas berlaku untuk seluruh permintaan. Untuk menjalankan bagian percakapan selanjutnya pada tingkat yang berbeda, atur nilai baru pada permintaan berikutnya. Karena effort tingkat atas membentuk prompt yang dirender, mengubahnya di antara permintaan tidak mempertahankan prefiks yang di-cache dari giliran sebelumnya. Jika Anda mengandalkan caching prompt sepanjang sesi yang panjang dan model Anda tidak mendukung effort per pesan, pilih tingkat effort di awal dan pertahankan agar tetap konstan.

#Praktik terbaik

1. Atur effort secara eksplisit: API secara default menggunakan high (medium pada Haijun Opus 5.5), tetapi titik awal yang tepat bergantung pada model dan beban kerja Anda.

1. Gunakan low untuk tugas yang sensitif terhadap kecepatan atau sederhana: Ketika latensi penting atau tugas bersifat sederhana, effort low dapat secara signifikan mengurangi waktu respons dan biaya.

1. Uji kasus penggunaan Anda: Dampak tingkat effort bervariasi menurut jenis tugas. Evaluasi kinerja pada kasus penggunaan spesifik Anda sebelum melakukan deployment.

1. Pertimbangkan effort dinamis: Sesuaikan effort berdasarkan kompleksitas tugas. Kueri sederhana mungkin cukup dengan effort low, sementara agentic coding dan penalaran kompleks mendapat manfaat dari effort high. Lihat poin berikutnya sebelum memvariasikannya dalam satu percakapan.

1. Pertahankan effort tingkat atas tetap konstan dalam percakapan yang di-cache: Mengubah nilai effort tingkat atas di antara permintaan membatalkan caching prompt, jadi variasikan di antara beban kerja alih-alih di dalam percakapan yang mengandalkan cache hit. Pada model yang mendukungnya, gunakan perubahan effort per pesan sebagai gantinya, yang mempertahankan cache. Lihat Pemikiran dan caching prompt.

#Langkah selanjutnya

Berikan Haijun anggaran token yang bersifat saran untuk seluruh loop agentic guna membantu model mengatur dirinya sendiri pada tugas agentic yang panjang.

Pahami adaptive thinking, di mana Haijun memutuskan kapan dan seberapa banyak berpikir, dan arahkan dengan effort serta prompting.

Pahami cara kerja thinking, kapan Haijun berpikir secara default, dan bagaimana thinking berinteraksi dengan effort.