Samouczek API GPT-6 Astra: tworzenie produkcyjnych agentów AI

TL;DR

GPT-6 Astra API w CometAPI najlepiej sprawdza się w trudnych przepływach pracy agentów, które łączą rozumowanie, kod, interakcję z przeglądarką lub komputerem oraz kilka zewnętrznych narzędzi. To model premium, więc zespoły powinny rezerwować go dla zadań, w których wyższy odsetek poprawnych ukończeń uzasadnia wyższe ceny za tokeny.

Praktyczny wzorzec projektowy to pętla wykonawcza z jawnymi narzędziami, uprawnieniami po stronie aplikacji, weryfikacją, budżetami i akceptacją człowieka dla działań o istotnych skutkach. Zacznij od Responses API, mierz koszt na zaakceptowane zadanie i kieruj rutynowe podzadania do tańszych modeli.

Kluczowe wnioski

• Astra celuje w profesjonalną pracę end-to-end zamiast izolowanej generacji tekstu.
• Najsilniejsze raportowane wzrosty koncentrują się na użyciu komputera, zadaniach terminalowych, automatyzacji, rozumowaniu naukowym i wieloetapowych profesjonalnych przepływach pracy.
• Asynchroniczne wywoływanie narzędzi, sterowanie w środku tury i dynamiczne aktualizacje rozumowania czynią długotrwałe pętle agenta bardziej elastycznymi.
• Model obsługuje okno kontekstu 1,05 mln tokenów, ale nadal konieczne są narzędzia wyszukiwania i zarządzanie stanem.
• Jakość produkcyjna zależy od uprawnień, idempotencji, walidacji, obserwowalności i ewaluacji poza promptem.

Czym jest Astra API i do jakich obciążeń agentów pasuje?

OpenAI opisuje Astrę jako swój najbardziej zdolny model do złożonego rozumowania, kodowania, użycia komputera, researchu i tworzenia dokumentów. Oficjalna specyfikacja zapewnia okno kontekstu 1 050 000 tokenów oraz limit wyjścia 128 000 tokenów. Tekst i obrazy są akceptowane jako wejście, natomiast tekst jest natywną modalnością wyjściową.

Wizualizacja premiery OpenAI GPT-6 Astra

Duże okno kontekstu zmniejsza potrzebę dzielenia każdego wejścia, ale nie powinno być traktowane jako system pamięci. Trwałe fakty, pozyskane dowody, tymczasowy stan wykonania i wyjścia narzędzi powinny pozostawać oddzielne, tak aby agent otrzymywał tylko to, czego potrzebuje do bieżącej decyzji.

Benchmarki agentów GPT-6 Astra

Najbardziej użyteczne ewaluacje to te, które wymagają obsługi oprogramowania, pracy w terminalu, interakcji wizualnej lub ukończenia profesjonalnego przepływu pracy. Zgłaszane przez OpenAI wyniki pokazują większe zyski w zadaniach ciężkich wykonawczo niż na szerokich indeksach inteligencji.

GPT-6 Astra prowadzi nad GPT-5.6 Sol i Claude Fable 5.1 w każdym wierszu benchmarku, gdzie wszystkie trzy modele mają zgłoszone wyniki. Jej najwęższa przewaga nad Claude Fable 5.1 to 2.1 punktu procentowego w Terminal-Bench 4.0, podczas gdy większe przewagi pojawiają się w AutomationBench, FrontierMath Tier 4 v2, GPQA Diamond i zadaniach migracji baz danych. OpenAI raportuje również 47% krótszy symulowany czas zadania w porównaniu OSWorld, co ma znaczenie, gdy latencja agenta wpływa na przepustowość biznesową.

Użyj wyników benchmarków, aby wybrać obciążenia do testów. Ostateczną decyzję podejmij na podstawie zestawu ewaluacyjnego zbudowanego z własnych narzędzi, uprawnień, trybów awarii i kryteriów akceptacji.

Które funkcje Astry zmieniają architekturę agenta?

Asynchroniczne wywoływanie narzędzi w GPT-6 Astra

Async tool calling pozwala modelowi kontynuować użyteczne rozumowanie, wywoływać niezależne narzędzia lub odpowiadać na niezwiązaną część żądania, podczas gdy aplikacja uruchamia wolną operację. Aplikacja nadal wykonuje narzędzie i musi zwrócić jego wynik przy użyciu oryginalnego ID wywołania.

Jest to przydatne, gdy przepływ pracy równocześnie odpyta magazyn danych, poczeka na renderowanie, sprawdzi kilka API i przygotuje raport. Niezależne działania mogą postępować współbieżnie zamiast zmuszać całą pętlę agenta do oczekiwania.

Sterowanie w środku tury w GPT-6 Astra

Mid-turn steering i aktualizacje rozumowania umożliwiają aplikacji dodawanie instrukcji podczas trwającej pracy lub zmianę nakładu rozumowania bez przepisywania oryginalnego prefiksu promptu. Wspiera to korektę i zmianę priorytetów podczas długotrwałej pracy.

Strukturyzowane projektowanie narzędzi w GPT-6 Astra

Wywoływanie funkcji i Structured Outputs dają narzędziom nazwane operacje i typowane argumenty. Model proponuje działanie, a aplikacja weryfikuje uprawnienia, schematy, budżety i reguły biznesowe przed wykonaniem. Ten podział jest bardziej niezawodny niż proszenie modelu o wyrażenie operacji zapisu w języku naturalnym.

Jak zaprojektować agenta Astra?

Konwencjonalne żądanie do modelu językowego podąża krótką ścieżką: prompt, model, odpowiedź. Agent potrzebuje obserwowalnej pętli:

Cel → wybór kontekstu → plan → wybór narzędzia → autoryzowane działanie → obserwacja → weryfikacja → ukończenie lub eskalacja

Każde przejście tworzy możliwą awarię: niepoprawny wybór narzędzia, źle sformułowane argumenty, błędnie zrozumiane wyjście, zduplikowane działania, nieautoryzowane zapisy, przekroczenia budżetu lub przedwczesne zakończenie. Otaczająca aplikacja musi zatem posiadać władzę wykonawczą i walidację.

Jak wywołać Astra API przez CometAPI?

GPT-6 Astra API w CometAPI używa identyfikatora modelu gpt-6-astra przez przepływ Responses kompatybilny z OpenAI. Wykonaj te kroki konfiguracji przed wysłaniem pierwszego żądania:

1. Utwórz konto CometAPI, włącz dostęp do GPT-6 Astra i wygeneruj klucz API.
2. Zainstaluj lub zaktualizuj OpenAI Python SDK poleceniem pip install --upgrade openai.
3. Przechowuj klucz i kompatybilną z OpenAI bazę URL w COMETAPI_KEY i COMETAPI_BASE_URL; nigdy nie umieszczaj sekretów produkcyjnych na stałe w kodzie.
4. Potwierdź, że endpoint Responses i identyfikator modelu gpt-6-astra są włączone dla przestrzeni roboczej, a następnie uruchom poniższy przykład.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url=os.environ["COMETAPI_BASE_URL"],
)

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input=(
        "Analyze this operational incident. Identify the probable root cause, "
        "propose a remediation plan, and separate confirmed facts from assumptions."
    ),
)

print(response.output_text)

Udana pierwsza integracja powinna zwrócić obiekt odpowiedzi i czytelne output_text. W produkcji dodaj jawne limity czasu, ponawiaj tylko błędy chwilowe oraz loguj ID żądania, model, latencję, użycie tokenów i końcowy status przepływu pracy.

Jak zbudować agenta Astra wywołującego narzędzia?

Poniższy przykład rozdziela narzędzia odczytu od narzędzia zapisu o istotnych skutkach. Model może zażądać zwrotu, ale kod aplikacji musi nadal zweryfikować autoryzację i kwalifikowalność.

tools = [
    {
        "type": "function",
        "name": "get_order",
        "description": "Read an order. This tool has no side effects.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
            "additionalProperties": False,
        },
    },
    {
        "type": "function",
        "name": "check_refund_eligibility",
        "description": "Check eligibility without issuing a refund.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
            "additionalProperties": False,
        },
    },
    {
        "type": "function",
        "name": "create_refund_request",
        "description": "Create a request after authorization and eligibility checks.",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string"},
                "reason": {"type": "string"},
            },
            "required": ["order_id", "reason"],
            "additionalProperties": False,
        },
    },
]

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    tools=tools,
    input=(
        "Order A18422 arrived damaged. Determine whether a refund is allowed. "
        "Do not create a request until eligibility has been verified."
    ),
)
``````python
import json

def execute_tool(name, arguments):
    if name == "get_order":
        return get_order(**arguments)
    if name == "check_refund_eligibility":
        return check_refund_eligibility(**arguments)
    if name == "create_refund_request":
        assert_user_is_authorized()
        assert_refund_is_eligible(arguments["order_id"])
        return create_refund_request(**arguments)
    raise ValueError(f"Unknown tool: {name}")

while True:
    calls = [item for item in response.output if item.type == "function_call"]
    if not calls:
        break

    outputs = []
    for call in calls:
        result = execute_tool(call.name, json.loads(call.arguments))
        outputs.append({
            "type": "function_call_output",
            "call_id": call.call_id,
            "output": json.dumps(result),
        })

    response = client.responses.create(
        model="gpt-6-astra",
        previous_response_id=response.id,
        tools=tools,
        input=outputs,
    )

print(response.output_text)

Model rekomenduje działania. Aplikacja posiada władzę wykonawczą. Narzędzie zapisu musi niezależnie egzekwować uprawnienia, limity, idempotencję i warunki polityki.

Jak zautomatyzować długotrwałe przepływy pracy z Astrą?

Produkcyjny agent researchowy powinien otrzymać strukturyzowany cel, a nie ogólną instrukcję zbadania kilku firm.

{
  "objective": "Create a competitor launch brief",
  "companies": ["Competitor A", "Competitor B", "Competitor C"],
  "required_fields": [
    "latest product",
    "launch date",
    "price",
    "key differentiators",
    "primary sources"
  ],
  "output": "executive brief"
}

1. Zdefiniuj cel. Ustal wymagane pola, format wyjścia, termin i kryteria akceptacji.
2. Pozyskaj dowody. Użyj wyszukiwania w sieci, wyszukiwania plików, baz danych lub systemów połączonych przez MCP dla aktualnych informacji.
3. Zweryfikuj dowody. Oznacz źródła podstawowe, wtórne, wnioski, konflikty i brakujące dane.
4. Eskaluj niepewność. Poproś o więcej dowodów lub ocenę człowieka, gdy pewność spada poniżej wymaganego progu.
5. Wytwórz i zweryfikuj artefakt. Sprawdź każde wymagane pole przed ogłoszeniem ukończenia.

Ten projekt czyni obsługę dowodów audytowalną i trzyma rozumowanie modelu oddzielnie od reguł akceptacji systemu.

Kiedy agent Astra powinien używać automatyzacji komputerowej?

Preferuj najbardziej strukturyzowany dostępny interfejs: baza danych lub interfejs zapytań, następnie API, potem MCP lub inne typowane narzędzie, a na końcu przeglądarka albo interakcja z komputerem. Strukturyzowane interfejsy dostarczają stabilne pola, przewidywalne błędy, uwierzytelnianie i wyjścia możliwe do odczytu maszynowego.

Automatyzacja komputera jest właściwa, gdy brak użytecznego API, trzeba obsłużyć aplikację legacy, przepływ zależy od inspekcji wizualnej albo agent musi przetestować prawdziwy interfejs użytkownika. Wyniki Astry 92.7% na ScreenSpot-Pro i 72.6% na OSWorld 2.0 wspierają jej użycie do interakcji wizualnych, ale takie przepływy nadal wymagają kontrolowanych środowisk i wyraźnych polityk.

Jak uczynić agentów Astra bezpiecznymi w produkcji?

Bezpieczeństwo agenta jest przede wszystkim problemem architektury aplikacji. OpenAI umieszcza Astrę na krytycznym progu możliwości w zakresie cyberbezpieczeństwa, co zwiększa znaczenie granic dostępu i audytowalności.

Rozdziel narzędzia odczytu i zapisu

Utrzymuj operacje odczytu szeroko dostępne tam, gdzie to właściwe, ale wymagaj ostrzejszych kontroli dla zapisów. Unikaj jednego ogólnego narzędzia, które może zarówno inspektować, jak i mutować wrażliwe systemy.

Wymagaj akceptacji dla działań o istotnych skutkach

Używaj bramek akceptacji dla usuwania danych, publikacji na zewnątrz, zmian w produkcji, nadawania uprawnień, wysyłania pieniędzy, anulowania kont lub wykonywania innych transakcji o wysokim wpływie.

Uczyń każdy zapis idempotentnym

Płatności, zwroty, wiadomości i aktualizacje kont powinny przyjmować klucz idempotencji, aby ponowienie nie tworzyło zduplikowanych skutków ubocznych.

Egzekwuj budżety poza promptem

Śledź budżety tokenów, wywołań narzędzi, finansowe, czasu ściennego i kroków przepływu pracy w kodzie. Kończ deterministycznie po osiągnięciu limitu.

Loguj trajektorię wykonania

Rejestruj cel, model, konfigurację rozumowania, wybrane narzędzie, argumenty, wynik, rezultat autoryzacji, zdarzenie akceptacji, błąd, ponowienie, użycie tokenów i status końcowy.

Cennik Astra API

Oficjalna stawka Standard to $10/M za wejście i $50/M za wyjście dla promptów w standardowym poziomie kontekstu. Żądania powyżej 272K tokenów wejściowych są rozliczane według wyższych stawek długiego kontekstu dla całego żądania.

Cena za token sama nie opisuje ekonomii agenta. Użyj następującej miary operacyjnej:

Koszt na zaakceptowane zadanie

= model tokens + tool charges + retries + infrastructure + human correction, divided by the number of correctly completed tasks.

Jak Astra wypada na tle innych modeli agentów?

Astra jest najsilniejszym wyborem, gdy wąskim gardłem jest trudna wieloetapowa egzekucja. Sol lepiej pasuje ekonomicznie, gdy istniejący przepływ już kończy się niezawodnie. Fable pozostaje konkurencyjny dla premium pracy o długim horyzoncie, podczas gdy Gemini oferuje inny profil kosztów i modalności dla aplikacji multimodalnych o dużej skali.

Praktyczny system może kierować zadaniami według złożoności zamiast wybierać jeden model dla każdego żądania.

Wybór GPT-6 Astra: optymalizacja kosztów i kiedy go używać

• Kieruj według mierzonej złożoności. Użyj routera wspartego ewaluacją, aby rezerwować GPT-6 Astra dla zadań, których głębokość rozumowania, użycie narzędzi lub koszt błędów uzasadnia eskalację.
• Cache’uj stabilne prefiksy. Ponownie używaj polityk, schematów i dokumentacji, które nie zmieniają się między żądaniami.
• Pobieraj relewantny kontekst. Nie wypełniaj okna miliona tokenów tylko dlatego, że jest dostępne.
• Ogranicz kroki agenta. Zdefiniuj warunki ukończenia i zatrzymania przed startem wykonania.
• Dostosuj nakład rozumowania. Używaj low lub medium dla deterministycznych podzadań i zwiększaj go tylko wtedy, gdy niejednoznaczność lub niepowodzenia weryfikacji uzasadniają koszt.
• Uruchamiaj niezależne narzędzia współbieżnie. Zmniejsz latencję zegara ściennego bez dodawania niepotrzebnych tur modelu.
• Zastosuj regułę finalnej decyzji. Użyj GPT-6 Astra do trudnego rozumowania połączonego z długohoryzontową egzekucją, inżynierią oprogramowania, obsługą komputera, wieloma zewnętrznymi narzędziami, tworzeniem profesjonalnych artefaktów lub wysokim kosztem błędu. Użyj tańszego modelu do klasyfikacji, ekstrakcji, tagowania, rutynowych podsumowań i niskowartościowych żądań wrażliwych na latencję — chyba że ewaluacje pokażą, że Astra materialnie obniża koszt na zaakceptowane zadanie.

Które metryki produkcyjne mają znaczenie dla agentów Astra?

Główną miarą produkcyjną jest odsetek prac ukończonych poprawnie, bezpiecznie i w ramach budżetu.

FAQ

Jaki jest identyfikator modelu Astra API?

Identyfikator modelu to gpt-6-astra.

Czy Astra wspiera wywoływanie funkcji?

Tak. Wspiera wywoływanie funkcji i Structured Outputs. Wywoływanie narzędzi powinno używać Responses API.

Czy Astra wspiera MCP?

Tak. MCP jest uwzględnione wśród narzędzi Responses API.

Czy Astra może sterować komputerem?

Tak. Obsługa komputera jest wspierana, ale aplikacja musi zapewnić kontrolowane środowisko, granice polityk i weryfikację.

Czym jest asynchroniczne wywoływanie narzędzi?

Pozwala modelowi kontynuować użyteczną pracę, gdy aplikacja wykonuje wolne asynchroniczne wywołanie narzędzia.

Czym jest sterowanie w środku tury?

Pozwala aplikacji wysyłać zaktualizowane instrukcje, gdy zadanie już trwa.

Jak duże jest okno kontekstu Astry?

Obsługuje 1,050,000 tokenów kontekstu i do 128,000 tokenów wyjścia.

Ile kosztuje Astra?

Cennik OpenAI Standard zaczyna się od $10/M za wejście i $50/M za wyjście dla standardowego poziomu kontekstu. Ceny bramek mogą się różnić w zależności od dostawcy i poziomu kontekstu.

Czy każdy agent powinien używać Astry?

Nie. Wybierz ją, gdy wyższe wskaźniki ukończenia równoważą jej wyższą cenę. Kieruj przewidywalne, wysokowolumenowe podzadania do tańszych modeli.

Czy mogę budować agentów Astra przez CometAPI?

Tak. CometAPI udostępnia przepływ Responses kompatybilny z OpenAI. Zweryfikuj każde narzędzie i parametr wymagany przez Twoją aplikację przed skierowaniem ruchu produkcyjnego.