Aprimore a observabilidade dos agentes de IA com o Langfuse, impulsionado pelo watsonx Orchestrate

By Jobit Varughese

Com o aumento diário no número de agentes de IA criados, as empresas estão explorando sistemas autônomos para apoiar a tomada de decisões e os fluxos de trabalho operacionais. Ao mesmo tempo, as organizações frequentemente expressam preocupações sobre explicabilidade, governança e prontidão para produção, especialmente em sistemas multiagentes que dependem de grandes modelos de linguagem (LLMs) para raciocínio. É um desafio utilizar agentes em ambientes corporativos que apresentam respostas sem uma explicação clara ou que exibem comportamentos inconsistentes.

Esses desafios podem ser resolvidos com o IBM watsonx Orchestrate, que oferece uma plataforma estruturada compatível com auto-hospedagem, raciocínio baseado em ferramentas, chamadas de API e controle em nível empresarial sem exigir código de orquestração personalizado.

A Dynamiq desenvolveu um assistente de pesquisa jurídica multiagente para um importante cliente do setor de seguros, encaminhando as consultas por meio de um classificador IBM Granite de baixo custo antes de escalá-las para um agente de pesquisa mais complexo. Tornar viável esse fluxo de trabalho de alto risco exigiu visibilidade profunda de cada etapa do raciocínio e chamada de ferramenta. Integrando o IBM watsonx Orchestrate, a Dynamiq garantiu que todas as decisões permanecessem totalmente rastreáveis, auditáveis e citadas, reduzindo o tempo de avaliações de contratos de 90 para 45 minutos sem sacrificar a governança.

Neste tutorial você aprenderá a criar um agente de IA no watsonx Orchestrate com o watsonx Orchestrate Agent Development Kit (ADK). Em sistemas de IA baseados em LangChain ou LangGraph, os desenvolvedores frequentemente lidam com novas tentativas, tratamento de estados e execução assíncrona manualmente. O watsonx Orchestrate ADK facilita esse processo por meio do gerenciamento integrado do ciclo de vida, que possibilita implementações consistentes e prontas para a empresa de agentes.

Você usará Python para criar a lógica de avaliação de risco, definir o comportamento dos agentes e incorporar o Langfuse para monitorar e aprimorar o comportamento dos agentes com rastreamentos de execução reais. Esse tutorial também encontra-se no GitHub..

O que é Langfuse?

Langfuse é uma plataforma de observabilidade de LLM de código aberto construída sobre o OpenTelemetry para monitorar aplicações e agentes LLM. Utiliza telemetria (rastreamentos, métricas e logs) para monitorar os rastros das execuções do agente, incluindo chamadas LLM, chamadas de ferramentas, uso de token, metadados e latência em nível de solicitação e sessão.

Ele possibilita que os desenvolvedores obtenham insights profundos sobre como os agentes atuam em cenários do mundo real, identifiquem as causas de saídas incorretas e otimizem sistematicamente o comportamento dos agentes para maior confiabilidade e eficiência.

Visão geral do caso de uso: inteligência de risco do fornecedor

O objetivo deste tutorial é criar um agente de IA para governança empresarial que avalie o risco dos fornecedores por meio de uma análise determinística baseada em regras. Criamos um conjunto de dados sintéticos de fornecedores com classificações financeiras, certificações de segurança e histórico de incidentes. O agente processa esses dados e classifica os fornecedores em níveis de risco específicos (baixo, médio ou alto), além de apresentar justificativas para suas decisões.

Suporta também acompanhamentos interativos, permitindo que os usuários comparem fornecedores ou simulem como a mudança de pontos de dados afetaria uma pontuação de risco, garantindo o alto nível de auditabilidade necessário para a conformidade corporativa.

Veja abaixo uma demonstração interativa do agente de risco do fornecedor concluído e construído neste tutorial. Explore como o agente classifica os fornecedores, responde às perguntas e rastreia seu raciocínio por meio do Langfuse, para você ter uma visão clara do que está criando antes de começar.

Demo prático

Pré-requisitos

Para concluir este tutorial, você precisa de:

Python 3.11 ou versão posterior instalado em seu sistema.
Uma conta do watsonx Orchestrate. Para este tutorial, uma conta de teste é suficiente. Você pode utilizar a IBM Cloud para criar uma avaliação gratuita de 30 dias quando não tiver uma conta.
Uma chave de API watsonx Orchestrate da interface de usuário (IU) do Orchestrate.
Um ADK do watsonx Orchestrate instalado em seu sistema.

Etapas

Etapa 1: Entre no watsonx Orchestrate

Faça login no watsonx Orchestrate pelo IBM Cloud e abra a IU do watsonx Orchestrate. Acesse os detalhes da API depois de abrir as Configurações no menu do perfil. Crie uma nova chave de API, copie e salve com segurança. Durante o desenvolvimento local, o watsonx Orchestrate ADK é autenticado com essa chave API. O watsonx Orchestrate funciona como um SDK local (Software Development Kit) para construir e testar a lógica dos agentes.

Etapa 2: Configure um ambiente de desenvolvimento local

Nesta etapa, crie um ambiente de desenvolvimento local. Neste tutorial você executará um servidor de desenvolvimento local, importará ferramentas, configurará ambientes e criará agentes por meio da interface de linha de comando Orchestrate (CLI) fornecida pelo ADK no PowerShell. Comece navegando até o diretório onde você deseja compilar o projeto. Em seguida crie um novo ambiente virtual do Python:

python -m venv .venv

É criado um ambiente Python isolado em uma pasta .venv. O uso de um ambiente virtual garante que todas as dependências deste tutorial sejam separadas da instalação do Python em todo o sistema.

Depois, ative o ambiente virtual. Seu sistema operacional determina qual comando de ativação usar.

No Windows:

.\.venv\Scripts\activate

macOS e Linux:

source ./.venv/bin/activate

Uma vez ativado, o prompt do seu terminal exibirá ".venv" no início para indicar que você está trabalhando em um ambiente virtual.

Etapa 3: Instale o watsonx Orchestrate ADK

Com o ambiente virtual ativo, instale o ADK do watsonx Orchestrate em sua máquina local. Para utilizar o ADK, conecte-o ao seu ambiente existente do watsonx Orchestrate. Execute o seguinte comando no PowerShell:

pip install --upgrade ibm-watsonx-orchestrate

Você pode seguir as próximas etapas da instalação do ADK seguindo as etapas do documento oficial de instalação.

Nota: Este tutorial roda localmente o watsonx Orchestrate Developer Edition tempo de execução e o conecta à instância SaaS watsonx Orchestrate com as credenciais.

Para executar este método, crie um arquivo chamado .env na raiz da pasta do projeto e adicione os seguintes valores:

WO_DEVELOPER_EDITION_SOURCE=orchestrate

WO_INSTANCE=<your_watsonx_orchestrate_instance_url>

WO_API_KEY=<your_watsonx_orchestrate_api_key>

Este arquivo .env O arquivo é necessário para executar o servidor. Nas Próximas etapas, você vai iniciá-lo com o comando orchestrate server start -e.env -l.

Etapa 4: Configure o ambiente watsonx Orchestrate no ADK

Em seguida você precisa configurar seu ADK com uma chave de API válida do watsonx Orchestrate para conectar seu ambiente local ao watsonx Orchestrate.

Observação: O watsonx Orchestrate ADK é compatível com vários tipos de ambiente, incluindo IBM Cloud, AWS e implementações locais. Neste tutorial utilizamos o ambiente local e autenticamos com uma chave de API por meio da CLI do ADK. O ADK gerencia as credenciais de forma segura internamente, portanto nenhuma configuração manual de variável de ambiente é implementada para essa configuração.

No diretório do projeto (com o ambiente virtual ativado), execute o seguinte comando para adicionar o ambiente do watsonx Orchestrate:

orchestrate env add -n onprem-env -u <service-instance-url>

Aqui, service-instance-url é o URL da sua instância do WatsonX Orchestrate. Essas informações encontram-se na mesma aba de detalhes da API em Configurações na interface do usuário do watsonx Orchestrate.

Em seguida, ative o ambiente que você adicionou:

orchestrate env activate onprem-env

Agora, quando solicitado, insira a chave do watsonx Orchestrate obtida na etapa 1. Quando o ambiente tiver sido ativado, todos os comandos subsequentes relacionados ao ADK, como a importação de agentes, ferramentas ou execução do servidor, serão executados no ambiente do watsonx Orchestrate.

Observação: Se você quiser executar tudo localmente com a Developer Edition, poderá ativar o ambiente local padrão através de:

orchestrate env activate local

Isso alterna seu ADK para o ambiente local integrado do Orchestrate, o que é útil para testes locais.

Etapa 5: Inicialize o projeto local do watsonx Orchestrate

Nesta etapa, você criará o modelo da estrutura do agente, que contém a definição, as ferramentas e o código-fonte do seu Agente de inteligência de risco de fornecedores. Em seguida, crie a estrutura de pastas necessária para o desenvolvimento baseado em ADK local:

── adk-project(vendor-risk-intel)/
── agents/
── tools/
── src/

Você pode adicionar o comando apresentado aqui para criar a estrutura do agente:

mkdir -p adk-project$vendor-risk-intel$/{agents,src,tools}

Cada pasta tem uma finalidade específica:

A pasta "agents" contém o arquivo YAML com as instruções, regras de raciocínio e configuração do modelo de agente. Ela determina como o sistema responde às perguntas dos usuários. A pasta de ferramentas contém um arquivo YAML que descreve a ferramenta disponibilizada para o agente. A pasta src contém a implementação em Python para ferramentas personalizadas e lógica de negócios.

Etapa 6: Inicie o servidor watsonx Orchestrate

Inicie o servidor do watsonx Orchestrate para receber e armazenar suas importações antes de importar ferramentas e agentes. Execute este comando na raiz da pasta do projeto:

orchestrate server start -e .env -l

Etapa 7: Configure a observabilidade do Langfuse (SaaS)

O próximo passo é a observabilidade do agente, onde você analisa como o agente se comporta em tempo de execução, como quais ferramentas são chamadas, latência e onde ocorrem erros. Para isso, ative a observabilidade do Langfuse no ambiente ADK do watsonx Orchestrate.

Neste tutorial, a versão Langfuse SaaS é usada, o que possibilita capturar rastreios sem executar o Langfuse localmente.

Certifique-se de que o servidor do watsonx Orchestrate esteja em execução (etapa 6) antes de configurar o Langfuse.

Em seguida, crie uma conta Langfuse em https://cloud.langfuse.com. Após entrar na conta, crie uma nova organização e projeto. Nas configurações do projeto, copie a ID do projeto, sua chave pública, sua chave secreta e o URL do host.

Agora configure o Langfuse no ADK do watsonx Orchestrate com o comando mostrado após esta seção e substitua os espaços reservados pelos seus valores copiados:

orchestrate settings observability langfuse configure `
    --url “<LANGFUSE_HOSTNAME>/api/public/otel” `
    --api-key “<LANGFUSE_SECRET_KEY>“ `
    --health-uri “https://cloud.langfuse.com” `
    --config-json “{\”public_key\”:\”<LANGFUSE_PUBLIC_KEY>\”}” `
    --project-id “<LANGFUSE_PROJECT_ID>“

Uma vez que esse comando seja concluído com sucesso, o módulo Langfuse será totalmente integrado ao ambiente watsonx Orchestrate. Neste estágio, todas as interações com os agentes são automaticamente registradas no módulo Langfuse.

Agora que o servidor está em execução, você pode testar o agente.

Etapa 8: Defina o agente de inteligência de risco do fornecedor

A próxima etapa é definir o Agente de inteligência de risco do fornecedor. Os agentes no watsonx Orchestrate ADK são declarados com arquivos YAML que descrevem o objetivo do agente, limitações de raciocínio, configuração do modelo e ferramentas permitidas.

No diretório agents, crie um arquivo chamado vendor-risk-agent.yaml. Esse arquivo é a camada de gerenciamento de prompt do agente que garante que todas as respostas se baseiem em raciocínio determinístico, em oposição à inferência livre.

Veja a seguir a definição do agente utilizada neste tutorial. Copie e cole a seguinte definição de agente no seu arquivo agents/vendor-risk-agent.yaml. Salve o arquivo depois.

spec_version: v1
kind: native
name: Vendor_Risk_Intelligence_Agent
description: Produces precise risk assessments using verified vendor profiles.
instructions: |
    You are a Vendor Risk Auditor.
    You MUST answer ALL questions by:
    1. Calling the Python tool `evaluate_all_vendor_risks`
    2. Reasoning strictly from the returned structured data
    3. Explaining answers using rules, signals, and outcomes from the tool
    4. Call evaluate_all_vendor_risks exactly once per question
    5. For definition questions, quote rules directly from the tool output
    NEVER infer meanings of financial ratings.
    NEVER guess intent.
    NEVER answer without tool evidence.
    Question handling rules:
    - Definition questions (e.g. “Does B+ mean High risk?”):
→ Explain the rule from the tool’s `rules` section.
    - Why questions (e.g. “Why is DataSecure Ltd High risk?”):
→ Cite strong and weak signals for that vendor.
    - Comparison questions (e.g. “Why is A Medium but B High?”):
→ Compare signal counts and types.
    - Policy questions (e.g. “What causes High risk?”):
→ Quote the tool’s rules exactly.
    - If the tool does not support a claim:
→ Say so explicitly.
    Use deterministic language only.
    Do not use speculative words like “might”, “could”, or “appears”.

llm: watsonx/meta-llama/llama-3-2-90b-vision-instruct
style: react
tools:
    - evaluate_all_vendor_risks

Essa configuração garante que o agente se comporte de forma previsível em perguntas de "o que", por que, como e comparação. O sistema evita alucinações proibindo suposições sobre classificações financeiras ou significados de riscos, a menos que a saída da ferramenta os defina explicitamente.

Etapa 9: Implemente a lógica de avaliação de risco do fornecedor

Nesta etapa, implemente a ferramenta Python que realiza a avaliação de risco do fornecedor. No ADK do watsonx Orchestrate, a lógica de negócios personalizada é implementada por meio de ferramentas em Python, que os agentes utilizam para obter os resultados. Em vez de depender do ajuste fino de um modelo para comportamento específico do domínio, este tutorial demonstra como o raciocínio determinístico baseado em regras pode ser implementado por meio de ferramentas Python, garantindo resultados uniformes.

Dentro da pasta src, crie um arquivo com o nome main.py. Este arquivo contém o conjunto de dados do fornecedor que criamos, as regras de avaliação de risco e uma ferramenta Python chamada evaluate_all_vendor_risks que fornece a lógica ao agente.

A lógica de risco baseia-se em regras. Em termos de sinais de alto risco, uma empresa pode receber uma pontuação de risco devido ao seu desempenho ruim, incidentes de segurança no passado ou consultas regulatórias. Uma empresa pode receber uma pontuação de risco média devido à ausência de certificações, incidentes operacionais únicos ou interrupções causadas por condições climáticas.

A função evaluate_all_vendor_risks foi criada como uma ferramenta do WatsonX Orchestrate, permitindo que o agente a invoque durante a execução. A ferramenta gera uma saída estruturada que inclui o nível de risco final junto com os motivos exatos que causaram a classificação.

Nota: O arquivo main.py incluído neste tutorial é a versão final atualizada da lógica de avaliação de risco do fornecedor. Os primeiros conjuntos de código causaram comportamentos errôneos dos agentes que foram analisados por meio dos rastreios do Langfuse. Você pode encontrar os rastreios do Langfuse nas capturas de tela apresentadas nas etapas posteriores deste tutorial.

Veja a seguir a implementação completa do arquivo main.py utilizado neste tutorial. Copie e cole em src/main.py. Depois salve o arquivo.

from ibm_watsonx_orchestrate.agent_builder.tools import tool

# =====================================================
# IN-MEMORY VENDOR DATA
# =====================================================

VENDORS = [
    {
        “name”: “CloudHostCo”,
        “financial_rating”: “A-“,
        “security_certifications”: [“ISO 27001”, “SOC2 Type II”],
        “past_incidents”: [{“type”: “Operational”, “year”: 2023}],
        “recent_news”: [“Minor service disruption in EU region”]
    },
    {
        “name”: “DataSecure Ltd”,
        “financial_rating”: “B”,
        “security_certifications”: [“SOC2 Type I”],
        “past_incidents”: [{“type”: “Security”, “year”: 2022}],
        “recent_news”: [“Suspicious login attempts on admin accounts”]
    },
    {
        “name”: “FinPay Solutions”,
        “financial_rating”: “A”,
        “security_certifications”: [“PCI-DSS”],
        “past_incidents”: [],
        “recent_news”: [“Regulatory inquiry about payment delays”]
    },
    {
        “name”: “GreenLogistics Corp”,
        “financial_rating”: “B+”,
        “security_certifications”: [“ISO 9001”],
        “past_incidents”: [{“type”: “Operational”, “year”: 2023}],
        “recent_news”: [“Weather-related disruptions in the UK”]
    }
]

REQUIRED_CERTS = {“ISO 27001”, “SOC2 Type II”, “PCI-DSS”}

# =====================================================
# RISK COMPUTATION (FIXED)
# =====================================================

def compute_vendor_risk(vendor: dict) -> dict:
    strong_signals = []
    weak_signals = []

  # ---------- Strong signals ----------

    # Financial risk ONLY for B or worse (NOT B+)
    if vendor[“financial_rating”] in {“B”, “B-“, “C”, “C-“, “D”}:
        strong_signals.append(“Weak financial rating”)

    # Security incident
    if any(i[“type”].lower() == “security” for i in vendor.get(“past_incidents”, [])):
        strong_signals.append(“Past security incident”)

    # Regulatory inquiry
    for news in vendor.get(“recent_news”, []):
        if “regulatory inquiry” in news.lower():
        strong_signals.append(“Regulatory inquiry”)
        break

    # ---------- Weak signals ----------

    # Missing key certifications
    certs = set(vendor.get(“security_certifications”, []))
    if not REQUIRED_CERTS.issubset(certs):
        weak_signals.append(“Missing key security certifications”)

    # Single operational incident
    incidents = vendor.get(“past_incidents”, [])
    if len(incidents) == 1 and incidents[0][“type”].lower() == “operational”:
        weak_signals.append(“Single operational incident”)

    # Weather-related disruptions are weak only
    for news in vendor.get(“recent_news”, []):
      if “weather” in news.lower():
        weak_signals.append(“Weather-related disruption”)
        break

    # ---------- Final decision ----------

    if len(strong_signals) >= 2:
        risk = “High”
    elif len(strong_signals) == 1 or len(weak_signals) >= 2:
        risk = “Medium”
    else:
        risk = “Low”

    return {
        “risk”: risk,
        “strong_signals”: strong_signals,
        “weak_signals”: weak_signals
    }

# =====================================================
# PYTHON TOOL
# =====================================================

@tool
def evaluate_all_vendor_risks() -> dict:
    “””
    Returns structured vendor risk assessments with explanations and rules.
    “””
    return {
        “rules”: {
            “financial_rating_rule”: “Only financial ratings of B or lower are treated as strong risk signals. B+ and above are not strong signals.”,
            “high_risk_rule”: “High risk requires two or more strong signals.”,
            “medium_risk_rule”: “Medium risk occurs with one strong signal or two or more weak signals.”,
            “weather_rule”: “Weather-related disruptions are always weak signals.”,
            “operational_rule”: “A single operational incident is a weak signal.”
        },
        “vendors”: {
            v[“name”]: {
                “financial_rating”: v[“financial_rating”],
                “risk”: compute_vendor_risk(v)[“risk”],
                “strong_signals”: compute_vendor_risk(v)[“strong_signals”],
                “weak_signals”: compute_vendor_risk(v)[“weak_signals”]
            }
            for v in VENDORS
        }
    }

Etapa 10: Importe a ferramenta e o agente Python para o watsonx Orchestrate.

Nesta etapa, a ferramenta e o agente devem ser disponibilizados para o watsonx Orchestrate. Esse processo é feito importando-se esses componentes no ambiente do ADK ativado. Antes de executar os comandos de importação, é importante que esteja dentro da pasta raiz do seu projeto (a mesma pasta que contém os diretórios agents, src e tools).

Primeiro, importe a ferramenta do Python para o watsonx Orchestrate registrá-la como recurso executável. Na raiz do diretório do projeto, execute o seguinte comando:

orchestrate tools import --kind python --file src/main.py --package-root .

Este comando empacota o código Python em um módulo, registra a ferramenta evaluate_all_vendor_risks e possibilita que seja chamada por agentes.

orchestrate agents import -f agents/vendor-risk-agent.yaml

O Agente de inteligência de risco do fornecedor é então totalmente integrado com a ferramenta Python no ambiente do watsonx Orchestrate.

Etapa 11: Teste o agente e analise seu comportamento com o Langfuse.

Com o servidor local do watsonx Orchestrate em execução e a observabilidade do agente habilitada, agora você pode testar o agente e analisar seu comportamento em tempo real.

Inicie a interface de chat com o seguinte comando:

orchestrate chat start

Agora abra a interface de chat do watsonx Orchestrate no seu navegador. No seletor de agentes, escolha Vendor_Risk_Intelligence_Agent e comece a fazer perguntas relacionadas ao risco do fornecedor.

Para verificar se o agente está respondendo corretamente (e chamando a ferramenta Python de forma determinística), veja a seguir algumas perguntas de exemplo que você pode utilizar para testar:

B+ significa alto risco?
Qual é o risco da DataSecure Ltd?
Quais são os critérios para risco médio?
Qual fornecedor tem a classificação financeira mais fraca?
Se as soluções da FinPay sofressem um incidente de segurança, como seu nível de risco mudaria?
Quais fornecedores sofreram incidentes operacionais?

Ao interagir com o agente, abra o dashboard do Langfuse no navegador. Cada consulta de usuário cria um novo rastreamento, inclui um session_id e uma ID de usuário. Esses rastreamentos registram o caminho completo de execução do agente. Ao selecionar um rastreio, você pode analisar:

A entrada e a saída completas do agente
A invocação da ferramenta Python
Os dados estruturados retornados pela ferramenta
O processo de raciocínio seguido para chegar à resposta final
Latência de cada etapa do processo
Fluxo de conversação baseado em sessão para várias perguntas

Essa observabilidade ajuda você a analisar as métricas de desempenho que apontam gargalos, como erros de suposição, regras incompletas ou comportamento inesperado do agente.

Etapa 12: Refine o comportamento do agente com insights do Langfuse.

Depois de testar o agente, utilize os rastreios do Langfuse para identificar respostas incorretas. O Langfuse mostra cada invocação de ferramenta, etapa de raciocínio e latência de resposta, facilitando a compreensão por que uma resposta foi produzida.

Nesse caso de uso, a análise de rastreamento revelou que algumas respostas incorretas ocorriam quando o agente deduzia significados financeiros ou respondia sem citar explicitamente evidências baseadas em regras. Para alterar essa ação, as instruções do agente e o código Python correspondente foram modificados para corrigir um pensamento rigoroso baseado em regras com a ação da ferramenta necessária.

Após reimportar os arquivos atualizados, o agente foi testado novamente. Os novos rastreios garantem que as respostas estejam firmemente enraizadas na produção da ferramenta estruturada, que as explicações fossem determinísticas e que as respostas a todas as perguntas descritivas estivessem corretas.

Esse processo de observação e refinamento mostra como o Langfuse auxilia no desenvolvimento seguro e sólido de agentes com base no feedback do usuário.

Explore a demonstração interativa abaixo para explorar o agente de risco do fornecedor e o rastreamento do Langfuse em ação.

Conclusão

Este tutorial orientou você na criação de um agente de IA estruturado e confiável com o watsonx Orchestrate, desenvolvido para a criação de agentes de nível empresarial. Com a integração da lógica simples do Python baseada em regras, instruções claras para os agentes e ferramentas reutilizáveis, você implementou um caso de uso na avaliação de riscos de fornecedores com código mínimo e máxima transparência.

A inclusão do Langfuse facilitou a detecção do comportamento dos agentes e a identificação dos problemas com o raciocínio para melhorar continuamente a precisão sem suposições. Essa abordagem ajuda as empresas a otimizar sistemas de agentes de ponta a ponta, automatizar fluxos de trabalho complexos e implementar sistemas de IA com total transparência.

Ainda mais importante é que juntos, o watsonx Orchestrate e o Langfuse possibilitam que as empresas projetem, depurem e dimensionem fluxos de trabalho agênticos e aplicação de IA com mais rapidez, com governança mais forte e raciocínio mais claro e tempo de desenvolvimento reduzido.

Jobit Varughese

Technical Content Writer

IBM

Comece a obter ROI: Guia prático para a IA agêntica

Aprenda como escalar a IA agêntica para um ROI mensurável em toda a sua empresa. Este playbook descreve as principais barreiras que limitam o impacto, como medir o ROI de forma eficaz e um framework prático para impulsionar a adoção bem-sucedida em toda a empresa.

Recursos

Proteja seus agentes

Ataques de inversão de modelos de IA agora custam em média US$ 6 milhões, expondo os desafios crescentes de proteger sistemas de IA e dados sensíveis.

Projetando uma companhia aérea nativa em IA em escala empresarial

Quando as margens são apertadas, cada ineficiência conta. Embora os sistemas legados continuem limitando o potencial da IA em toda a aviação, a Riyadh Air escolheu um caminho diferente. Em parceria com a IBM, a Riyadh Air construiu a primeira companhia aérea nativa em IA do mundo, redefinindo uma maneira mais inteligente, rápida e intuitiva de viajar.

A empresa em 2030: projetada para inovação perpétua

Descubra nossas cinco previsões sobre o que definirá as empresas mais bem-sucedidas em 2030 e as medidas que líderes podem tomar para se beneficiarem ao priorizar a IA.

Imperativo da governança de IA: evolução das regulamentações e surgimento da IA agêntica

Aprenda como a evolução das regulamentações e o surgimento de agentes de IA estão remodelando a necessidade de frameworks robustos de governança de IA.

Explicação sobre a IA agêntica

O Techsplainers da IBM detalha os fundamentos da IA agêntica, desde os conceitos-chave até os casos de uso do mundo real. Episódios claros e rápidos ajudam você a aprender os fundamentos com agilidade.

Libere o ROI da IA: guia tático para produtividade empresarial

Aprenda estratégias comprovadas para aumentar a produtividade e impulsionar a transformação empresarial com IA e inovação no núcleo.

Como os agentes e assistentes de IA podem trazer benefícios para a sua organização

Aprofunde-se neste guia abrangente que detalha os principais casos de uso e recursos, fornecendo recomendações passo a passo para ajudar você a escolher as soluções certas para sua empresa.

Reinvente a produtividade de negócios com agentes e assistentes de IA

Saiba como agentes de IA e assistentes de IA podem trabalhar juntos para atingir novos níveis de produtividade.

Experimente o watsonx Orchestrate

Explore como assistentes de IA generativa podem aliviar sua carga de trabalho e melhorar a produtividade.

De projetos de IA a lucros: como a IA agêntica pode sustentar retornos financeiros

Descubra como as organizações estão evoluindo de projetos-piloto isolados de IA para impulsionar a transformação central dos negócios com IA agêntica.

Relatório da Omdia sobre inteligência capacitada: o impacto dos agentes de IA

Descubra como você pode liberar todo o potencial da IA generativa com agentes de IA.

Como os agentes de IA reinventarão a produtividade

Aprenda maneiras de usar a IA para ser mais criativo e eficiente e começar a se adaptar a um futuro que envolve trabalhar em estreita colaboração com agentes de IA.

A vanguarda das empresas agênticas: colocando a IA para trabalhar em todo o seu portfólio de tecnologias

Mantenha-se a par dos novos agentes de IA, um ponto de ruptura fundamental na revolução da IA.

O futuro dos agentes, o consumo de energia da IA, o uso de computadores da Anthropic e textos gerados por IA com a marca d'água do Google

Fique à frente da curva com nossos especialistas em IA neste episódio de Mixture of Experts enquanto eles se aprofundam no futuro dos agentes de IA e muito mais.

Como a Comparus está usando um "assistente bancário"

A Comparus usou as soluções do watsonx.ai e demonstrou de forma impressionante o potencial dos serviços bancários conversacionais como um novo modelo de interação.

Soluções relacionadas

Agentes de IA para empresas

Crie, implemente e gerencie assistentes e agentes de IA potentes que automatizam fluxos de trabalho e processos com a IA generativa.

Explore o watsonx Orchestrate

Soluções de agentes de IA da IBM

Construa o futuro do seu negócio com soluções de IA em que você pode confiar.

Explore soluções de agentes de IA

Serviços de IA do IBM® Consulting

Os serviços de IA da IBM Consulting ajudam a reinventar a forma como as empresas trabalham com IA para gerar transformação.

Explore os serviços de inteligência artificial

Dê o próximo passo

Se você optar por personalizar aplicativos e habilidades criados previamente ou criar e implementar serviços agênticos personalizados usando um estúdio de IA, a plataforma IBM watsonx tem aquilo de que você precisa.