Source: https://ailoot.ai/models/da/claude-opus-4-20250514-thinking/
Canonical: https://ailoot.ai/models/da/claude-opus-4-20250514-thinking/
Language: da

# claude-opus-4-20250514-thinking

[Markdown](https://ailoot.ai/models/da/claude-opus-4-20250514-thinking/index.md) · [JSON](https://ailoot.ai/models/da/claude-opus-4-20250514-thinking/facts.json)

## [claude-opus-4-20250514-thinking](https://ailoot.ai/models/da/claude-opus-4-20250514-thinking/)

Claude Opus 4 Thinking bruger den oprindelige Opus 4’s udvidede ræsonnementstilstand til komplekse softwareændringer, vedvarende agentforløb og forskning. Den kan ræsonnere mellem understøttede værktøjstrin og forbinde belæg på tværs af en krævende opgave, før den producerer et tekstresultat.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `claude-opus-4-20250514-thinking`](https://ailoot.ai/models/da/claude-opus-4-20250514-thinking/#method-0)

Om modellen

Denne beskrivelse dækker modellens funktioner. Tilgængelige input, output og indstillinger i Ailoot står nedenfor for den valgte metode.

Claude Opus 4 Thinking anvender udvidet ræsonnement på den oprindelige Claude Opus 4-model. Anthropic positionerer denne generation til vanskeligt programmeringsarbejde, forskning, skrivning og opgaver, som kræver, at retningen fastholdes gennem mange trin. Betegnelsen Thinking vedrører modellens tilgang til et svar; den gør ikke den oprindelige Opus 4 til en senere Opus-udgave.

#### Ræsonnement på tværs af en krævende opgave

Claude Opus 4 kombinerer en standardsvartilstand med en udvidet ræsonnementstilstand. Ved udvidet ræsonnement kan den bruge mere tid på at undersøge et problem, før den svarer. Udvikleren beskriver vedvarende arbejde på komplekse opgaver som en central styrke, især når en opgave kræver, at en sekvens af observationer forbindes, frem for at isolerede prompts løses.

Ved et forskningsspørgsmål gives de materialer, der skal sammenlignes, den beslutning de skal understøtte, og de relevante betingelser. Bed om en evidensbaseret syntese, der skelner mellem observationer, antagelser og åbne spørgsmål. Ved en skriveopgave medtages målgruppe, kildemateriale, krævet struktur og de påstande, resultatet skal forklare. Det er praktiske anvendelser af modellens dokumenterede forsknings- og skrivemuligheder frem for løfter om et bestemt resultat.

#### Ændringer på tværs af en kodebase

Anthropic fremhæver kompleks kodeforståelse, redigering, fejlfinding og ændringer på tværs af flere filer. Giv modellen de relevante moduler, grænsefladekontrakter, forventet adfærd og eksisterende test eller fejloutput. Definer omfanget af den ønskede ændring, og bed om en forklaring af de afhængigheder, som gør de foreslåede redigeringer nødvendige.

Et nyttigt udviklingsresultat forbinder tre ting: årsagen til problemet, en sammenhængende implementering og en måde at kontrollere den resulterende adfærd på. Ved kodeomstrukturering angives de offentlige grænseflader og observerbare adfærdsmønstre, som skal forblive stabile. Ved en funktion beskrives brugerforløbet og dets fejltilfælde. Det gør modellens vedvarende ræsonnement nyttigt for projektet frem for blot at producere et længere svar.

#### Værktøjer, parallelt arbejde og kontinuitet

Den oprindelige Claude 4-generation tilføjer ræsonnement mellem værktøjskald i Anthropics dokumenterede forløb for udvidet ræsonnement. Den kan undersøge et værktøjsresultat, genoverveje tilgangen og vælge en efterfølgende handling. Udvikleren beskriver også parallel værktøjsbrug og forbedret kontinuitet, når en applikation giver lokale filer, som modellen kan læse og opdatere.

En agent, som bruger disse muligheder, har brug for en applikation, der stiller værktøjerne til rådighed, udfører anmodede handlinger og returnerer resultaterne. Hukommelsesfiler hører ligeledes til applikationsmiljøet; de er ikke et ubegrænset lager, som automatisk følger med mellem uvedkommende samtaler. Ved udformning af et forløb returneres relevante observationer til modellen, og opgavens mål og acceptkriterier holdes tilgængelige.

#### Visuel analyse og tekstoutput

Claude Opus 4 understøtter også visuel analyse. Skærmbilleder, grafer og diagrammer kan give belæg sammen med tekst, mens modellens svar fortsat er tekst. Brug tydeligt læsbare billeder, og angiv de sammenhænge, du vil have forklaret. Medtag kildeværdier, når opgaven afhænger af præcise antal eller målinger, da visuel fortolkning kan være tilnærmet.

Ved en Ailoot API-opgave angives det nødvendige slutresultat: et ændringsforslag på tværs af flere filer, en teknisk undersøgelse, en forskningssyntese eller et omhyggeligt struktureret dokument. Tilføj de belæg og begrænsninger, der lader modellen vælge en tilgang. Udviklerens opsummeringer af udvidet ræsonnement giver en forklaring sammen med resultatet, men en opsummering er ikke en ordret gengivelse af alt ræsonnement. Undersøg den leverede kode eller analyse mod opgavens krav, herunder antagelser som stadig kræver belæg.

Praktisk opgave

### Praktisk opgave

Teknisk eksempel på engelsk

```
Plan a coordinated order refactor

Review this proposed refactor. Module A emits {order_id, total_cents}; module B stores those fields; module C displays total_cents / 100. A developer proposes renaming only A to amount_cents. Identify affected contracts and propose a coordinated migration that preserves existing consumers, with checks for old and new records.
```

#### Forventet resultat

```
A dependency map in text, a staged migration proposal and compatibility checks for each consumer.
```

#### Kontrollér resultatet

```
Confirm the proposal covers B and C and does not silently reinterpret cents as whole currency units.
```

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `claude-opus-4-20250514-thinking`

[`claude-opus-4-20250514-thinking`](https://ailoot.ai/models/da/#m=claude-opus-4-20250514-thinking&route=Ultra&caller=claude-opus-4-20250514-thinking&fmt=chat)

Anthropic /`claude-opus-4-20250514-thinking`

### Start

Claude Opus 4 Thinking bruger den oprindelige Opus 4’s udvidede ræsonnementstilstand til komplekse softwareændringer, vedvarende agentforløb og forskning. Den kan ræsonnere mellem understøttede værktøjstrin og forbinde belæg på tværs af en krævende opgave, før den producerer et tekstresultat.

Accepterede input

Tekst

Resultater

Tekst

### Tilgængelig i Ailoot · input og metoder

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`

Inputtyper

`text`

Outputtyper

`text`

Outputformat

json eller SSE

| Felt | Type | Krav | Værdier og grænser | Standard |
| --- | --- | --- | --- | --- |
| Felt`model` | Type`string` | KravPåkrævet | Værdier og grænser claude-opus-4-20250514-thinking | Standard— |
| Felt`messages` | Type`message[]` | KravPåkrævet | Værdier og grænser Minimumsantal elementer: 1 | Standard— |
| Felt`messages[].role` | Type`string` | KravPåkrævet | Værdier og grænser Eksempler: system, user, assistant, tool, function Betingelser: Disse roller er eksplicit repræsenteret i kildekodens kompatibilitetstyper; modellens præcise rollesæt er fortsat modelspecifikt. Afhænger af modellen | Standard— |
| Felt`messages[].content` | Type`string\|content_part[]\|null` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`messages[].tool_calls` | Type`tool_call[]` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`messages[].tool_call_id` | Type`string` | KravValgfrit | Værdier og grænser Gælder når: role=tool; brug det faktisk returnerede ID | Standard— |
| Felt`messages[].name` | Type`string` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`messages[].reasoning_content` | Type`string` | KravValgfrit | Værdier og grænser Gælder når: Send det faktisk returnerede ræsonnement tilbage, når modellen bruger det | Standard— |
| Felt`messages[].reasoning_details` | Type`object\|array` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`max_tokens` | Type`integer` | KravValgfrit | Værdier og grænser Minimum: 1 Afhænger af modellen | Standard— |
| Felt`max_completion_tokens` | Type`integer` | KravValgfrit | Værdier og grænser Minimum: 1 Afhænger af modellen | Standard— |
| Felt`stream` | Type`boolean` | KravValgfrit | Værdier og grænser | Standardfalse |
| Felt`stream_options.include_usage` | Type`boolean` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`temperature` | Type`number` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`top_p` | Type`number` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`stop` | Type`string\|string[]` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`tools` | Type`function_tool[]` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`tools[].type` | Type`string` | KravValgfrit | Værdier og grænser function Afhænger af modellen | Standard— |
| Felt`tools[].function.name` | Type`string` | KravPåkrævet | Værdier og grænser Gælder når: funktionsværktøj angivet | Standard— |
| Felt`tools[].function.description` | Type`string` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`tools[].function.parameters` | Type`JSON_schema` | KravValgfrit | Værdier og grænser | Standard— |
| Felt`tool_choice` | Type`string\|object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`parallel_tool_calls` | Type`boolean` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`response_format` | Type`object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`reasoning_effort` | Type`string` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`reasoning` | Type`object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`service_tier` | Type`string` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`instructions` | Type`string` | KravValgfrit | Værdier og grænser Kompatibilitetsfelt | Standard— |
| Felt`functions` | Type`function[]` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`function_call` | Type`string\|object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`prompt_cache_options` | Type`object` | KravValgfrit | Værdier og grænser Afhænger af modellen | Standard— |
| Felt`modalities` | Type`string[]` | KravValgfrit | Værdier og grænser text | Standard— |
| Felt`provider` | Type`object` | KravValgfrit | Værdier og grænser Betingelser: provider.options afvises på denne Ultra-tekstrute | Standard— |
| Felt`cache_control.ttl` | Type`string` | KravValgfrit | Værdier og grænser Betingelser: 1h afvises på de faktiske placeringer for promptcaching | Standard— |

Kombinationer af inputmaterialer

**Tekst** · UTF8-tekst

`messages[].content`

Metodeparametre og livscyklus

| Parameter | Kontrakt |
| --- | --- |
| Parameter`content_type` | Kontraktapplication/json |
| Parameter`required` | Kontraktmodel, messages |
| Parameter`material_types` | Kontrakttext |
| Parameter`messages` | Kontraktbeskedarray med strukturen role/content |
| Parameter`file_material` | Kontraktfaktisk UTF-8-dokument indsat som bogstavelig tekst; intet fil-ID udledes |
| Parameter`optional_controls` | Kontraktstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | Kontraktmodelspecifikt; brugerens funktionsværktøjer er forskellige fra hostede værktøjer |
| Parameter`output_modalities` | Kontrakttext |
| Parameter`hosted_operations` | Kontraktfalse |
| Parameter`multimodal_input_binding` | Kontraktnull |

Livscyklus: `synchronous_or_streamed`

Send det præcise model-ID med messages.

Kontekstlængde er ikke et outputloft.

En tekstfil kan levere bogstavelig tekst; billed-, lyd- og filobjektinput kræver en præcis binding.

### Priser

Tarifoplysninger tilføjer ikke anmodningsmuligheder. Understøttede parametre står ved den valgte metode.

Hurtig tilstand

Ikke angivet Når hurtig tilstand er valgt

flex-tilstand

Ikke angivet Når flex-tilstanden er valgt

Maksimal ræsonneringsindsats

Ikke angivet Når default-justeringen anvendes ved maksimal ræsonneringsindsats

#### Ailoot-takster

#### Priser efter konfiguration

| Konfiguration | Takstplan | Beløb |
| --- | --- | --- |
| KonfigurationGrundtakster for tokens | TakstplanGrundtakst | Beløb Input · Inputtokens **$0.03** / 1K tokens Output · Outputtokens **$0.15** / 1K tokens Input · Cachelæsning **$0.0006** / 1K tokens Input · Cacheskrivning **$0.0075** / 1K tokens Input · Cacheskrivning, 1 time **—** / 1K tokens |

Ailoot reserverer et estimeret beløb før en anmodning. Efter resultatet afregnes det endelige beløb ud fra det målte forbrug. Ved streaming bruges den endelige forbrugsregistrering til afregningen. [Sådan fungerer reservation og afregning →](https://ailoot.ai/docs/da/billing/reserve/)

### Eksempelanmodninger

#### Ailoot Ultra · OpenAI Chat

curlPython SDKPython-stream

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "claude-opus-4-20250514-thinking", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model='claude-opus-4-20250514-thinking',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))
```

```python
from openai import OpenAI
import os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.chat.completions.stream(model='claude-opus-4-20250514-thinking',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_completion()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Hent og gem resultater

#### Ailoot Ultra · OpenAI Chat

json eller SSE

##### Behold alle færdige resultater

Gem hvert fuldstændigt returneret svar, hver fil og hver indholdsdel.

Bevar hvert valg og dets indhold, værktøjskald og ræsonnement. Saml i SSE deltaer efter valg-/værktøjsindeks, og bevar den endelige afslutningsårsag og forbrugsoplysningerne.

##### Hvis det oprindelige svar skal kontrolleres

Bevar anmodnings-/svar-ID’er og headere. Der leveres ingen generel URL til at hente tekstjob.

Svarfelter

| Felt | Type |
| --- | --- |
| Felt`choices[].index` | Typeinteger |
| Felt`choices[].message.content` | Typestring\|null |
| Felt`choices[].message.tool_calls` | Typetool\_call\[\] |
| Felt`choices[].message.reasoning_content` | Typestring |
| Felt`choices[].message.reasoning_details` | Typeobject\|array |
| Felt`choices[].finish_reason` | Typestring\|null |
| Felt`usage` | Typeobject |

Fejl og næste trin

| Svar | Betingelse | Næste trin |
| --- | --- | --- |
| Svar400 · `invalid_request_error` | BetingelseUgyldige obligatoriske felter, materialerepræsentation eller parameterværdi | Næste trinRet de angivne felter før en ny oprettelsesanmodning. |

### Aliaser

#### Modelaliaser

**Ailoot Ultra** [`claude-opus-4-20250514-thinking`](https://ailoot.ai/models/da/#m=claude-opus-4-20250514-thinking&route=Ultra&caller=claude-opus-4-20250514-thinking&fmt=chat)

#### Aliaser for metodestier

Brug metodestierne vist ovenfor.

#### Relaterede kalder-ID’er

[`claude-opus-4-20250514-thinking`](https://ailoot.ai/models/da/#m=claude-opus-4-20250514-thinking&route=Ultra&caller=claude-opus-4-20250514-thinking&fmt=chat)

FAQ · claude-opus-4-20250514-thinking

Hvilke input og resultater er tilgængelige?

`POST /v1/chat/completions` · `claude-opus-4-20250514-thinking`: `text` → `text`

Hvilke felter bruger anmodningen?

`POST /v1/chat/completions` · `claude-opus-4-20250514-thinking`: `model`, `messages`, `stream`, `modalities`, `provider`

Hvilke grænser gælder?

`POST /v1/chat/completions` · `claude-opus-4-20250514-thinking`: `messages.min_items`: `1`

Tilslut Ailoot til Claude Code, OpenCode, Hermes eller din egen applikation.

## Virksomheden og dens projektportefølje

Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder.

## Køb tokens med rabat.

Abonnementsrabat til regelmæssigt arbejde. Rabatkoder giver op til 50% på tokenkøb.

Abonnement

Vælg et abonnement med rabat til dine regelmæssige anmodninger.

Rabatkode på op til 50%

Indtast koden ved købet. Prisen genberegnes efter den aktuelle kampagne.

Udgifter i historikken

Model, tokens og beløb gemmes for hver anmodning.

[Vælg abonnement](https://ailoot.ai/docs/da/billing/subscriptions/) · [Se modelpriser](https://ailoot.ai/models/da/)

## Tilslut API’et til produktet, du sælger.

SaaS, apps og bots efter Ailoots tilbudsvilkår og licensaftale. Anmod om en forhandlerlicens til videresalg.

Kommerciel applikation

Byg generering af tekst, billeder, video og lyd ind i tjenestens betalte funktioner.

Licens til forhandlere

Send projektbeskrivelse og adgangsmodel. Bed om skriftlige vilkår for anvendelse og videresalg.

Dokumenter på websitet

Tilbudsvilkår, licensaftale og politik for behandling af data kan læses før tilslutning.

[Anmod om forhandlerlicens](mailto:support@ailoot.ai) · [Tilbudsvilkår og licensaftale](https://ailoot.ai/legal/offer?lang=da)

## Ailoot · Virksomheden og dens projektportefølje





Ailoot bygger på solid driftserfaring, en stor kundebase, stabil service og løbende kontrol af KPI.





Virksomheden og dens projektportefølje: millioner af kunder; månedligt salg for milliarder.





Ailoot bruger denne driftserfaring til API-adgang til AI-funktioner i kundernes produkter, agenter, applikationer og automatiseringer.