Una mentor para sistemas de IA multiagente

Un oficial de crédito junior que se encarga solo de la sumario de datos, la evaluación de riesgos y las decisiones finales es propenso a cometer errores porque el rol exige demasiado a la vez. La misma pasión aparece en los agentes monolíticos de IA a los que se les pide que ejecuten flujos de trabajo complejos y de varias etapas. Pierden contexto, se saltan pasos y producen razonamientos inestables, lo que conduce a resultados poco confiables.

Un enfoque más sólido es disponer la IA como un equipo supervisado de especialistas que impongan el orden y la responsabilidad. Esto refleja la colaboración de expertos y produce decisiones más consistentes y auditables en ámbitos de parada peligro como los préstamos. En este artículo, construimos dicho sistema coordinado, no como un único agente sobrecargado de trabajo, sino como un equipo disciplinado.

¿Qué es un Agente Supervisor?

Un agente supervisor ya no es un agente singular que realiza una tarea, sino más proporcionadamente el catalogador de un equipo de otros agentes que trabajan en una tarea. Considérelo como el dirigente del sección de su AI fuerza gremial.

Sus responsabilidades secreto incluyen:

• Descomposición y delegación de tareas: El supervisor toma una solicitud entrante y la descompone en subtareas lógicas que luego se envía al agente especializado adecuado.
• Orquestación del flujo de trabajo: Es cumplidor en el orden de las operaciones. En el caso de nuestra revisión de préstamos, eso implica la recuperación de datos, la revisión de políticas y, solo a posteriori de eso, una recomendación.
• Control de calidad: Comprueba el desempeño de cada agente trabajador para ver si cumple con el standard requerido ayer del ulterior paso.
• Síntesis de resultados: Una vez que todos los agentes trabajadores están listos, el supervisor toma los resultados de los trabajadores y los sintetiza para dar un resultado final coherente.

El resultado de este patrón son sistemas más robustos, escalables y más fáciles de depurar. A los agentes se les asigna una tarea y esto simplifica su deducción y aumenta la estabilidad de su desempeño.

Ejercicio: automatización de revisiones de préstamos con un supervisor

Actualmente se está construyendo el sistema de primera revisión de la automatización de solicitudes de préstamos. Nuestro objetivo es tomar la identificación de un solicitante, evaluarlo en términos de políticas de peligro de la empresa y asesorarlo sobre una argumento concisa a tomar.

Nuestro equipo de IA estará formado por:

1. Agente de admisión de casos: Doble en recibimiento. Recoge la información financiera del solicitante y elabora un breviario.
2. Agente Comprobador de Políticas de Riesgos: El analista. Coteja la información del solicitante con una serie de criterios de préstamo preestablecidos.
3. Agente de valor de préstamos: El que toma las decisiones. Toma los descubrimientos y sugiere un curso de argumento final, como aprobar o repeler el préstamo.
4. El supervisor: El supervisor que realiza todo el flujo de trabajo y se asegura de que cada agente haga poco en la secuencia correcta.

Construyamos este equipo financiero.

Paso 1: instalar dependencias

Nuestro sistema se basará en LangChain, LangGraph y OpenAI. LangGraph es una biblioteca desarrollada para crear flujos de trabajo multiagente con estado.

!uv pip install langchain==1.2.4 langchain-openai langchain-community==0.4.1 langgraph==1.0.6 

Paso 2: Configurar las claves API y el entorno

Configure su secreto API OpenAI para potenciar nuestros modelos de habla. La ulterior celda le pedirá que ingrese su secreto de forma segura.

import os
import getpass

# OpenAI API Key (for chat & embeddings)
if not os.environ.get("OPENAI_API_KEY"):
    os.environ("OPENAI_API_KEY") = getpass.getpass(
        "Enter your OpenAI API key (https://platform.openai.com/account/api-keys):n"
    )

Paso 3: Importaciones

La definición del estado, las herramientas y los agentes requerirá varios utensilios de nuestras bibliotecas.

from typing import Annotated, Igual
from typing_extensions import TypedDict
from langgraph.graph.message import add_messages
from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI
from langgraph.types import Command
from langchain_core.tools import tool
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langchain.agents import create_agent
from IPython.display import display, Markdown

Paso 4: La deducción empresarial: conjuntos de datos

Operaremos nuestro sistema con datos básicos en memoria que serán una representación de políticas de peligro, recomendaciones de préstamos y registros de solicitantes. Esto hace que nuestro ejemplo sea autónomo y acomodaticio de seguir.

risk_policies = (
    {
        "loan_type": "Home Loan",
        "risk_category": "Low Risk",
        "required_conditions": (
            "credit_score >= 750",
            "stable_income >= 3 years",
            "debt_to_income_ratio < 30%"
        ),
        "notes": "Eligible for best interest rates and fast-track approval."
    },
    {
        "loan_type": "Home Loan",
        "risk_category": "Medium Risk",
        "required_conditions": (
            "credit_score >= 680",
            "stable_income >= 2 years",
            "debt_to_income_ratio < 40%"
        ),
        "notes": "May require collateral or higher interest rate."
    },
    {
        "loan_type": "Personal Loan",
        "risk_category": "Medium Risk",
        "required_conditions": (
            "credit_score >= 650",
            "stable_income >= 2 years"
        ),
        "notes": "Manual verification recommended for income consistency."
    },
    {
        "loan_type": "Coche Loan",
        "risk_category": "Low Risk",
        "required_conditions": (
            "credit_score >= 700",
            "stable_income >= 2 years"
        ),
        "notes": "Vehicle acts as secured collateral."
    }
)

loan_recommendations = (
    {
        "risk_category": "Low Risk",
        "next_step": "Coche approve loan with standard or best interest rate."
    },
    {
        "risk_category": "Medium Risk",
        "next_step": "Approve with adjusted interest rate or require collateral."
    },
    {
        "risk_category": "High Risk",
        "next_step": "Reject or request guarantor and additional documents."
    }
)

applicant_records = (
    {
        "applicant_id": "A101",
        "age": 30,
        "employment_type": "Salaried",
        "annual_income": 1200000,
        "credit_score": 780,
        "debt_to_income_ratio": 25,
        "loan_type": "Home Loan",
        "requested_amount": 4500000,
        "notes": "Working in MNC for 5 years. No missed EMI history."
    },
    {
        "applicant_id": "A102",
        "age": 42,
        "employment_type": "Self Employed",
        "annual_income": 900000,
        "credit_score": 690,
        "debt_to_income_ratio": 38,
        "loan_type": "Home Loan",
        "requested_amount": 3500000,
        "notes": "Business income fluctuates but stable last 2 years."
    },
    {
        "applicant_id": "A103",
        "age": 27,
        "employment_type": "Salaried",
        "annual_income": 600000,
        "credit_score": 640,
        "debt_to_income_ratio": 45,
        "loan_type": "Personal Loan",
        "requested_amount": 500000,
        "notes": "Recent job change. Credit card utilization high."
    }
)

Paso 5: Creación de herramientas para nuestros agentes

Todo agente requiere dispositivos para comunicarse con nuestros datos. son simples Pitón funciones adornadas con la útil de escenografía Python; que son invocados por el LLM cuando se le pide que haga ciertas cosas.

llm = ChatOpenAI(
    model="gpt-4.1-mini",
    temperature=0.0,
    timeout=None
)

@tool
def fetch_applicant_record(applicant_id: str) -> dict:
    """
    Fetches and summarizes an applicant financial record based on the given applicant ID.
    Returns a human-readable summary including income, credit score, loan type,
    debt ratio, and financial notes.

    Args:
        applicant_id (str): The unique identifier for the applicant.

    Returns:
        dict: {
            "applicant_summary": str
        }
    """
    for record in applicant_records:
        if record("applicant_id") == applicant_id:
            summary = (
                "Here is the applicant financial summary report:n"
                f"Applicant ID: {record('applicant_id')}n"
                f"Age: {record('age')}n"
                f"Employment Type: {record('employment_type')}n"
                f"Annual Income: {record('annual_income')}n"
                f"Credit Score: {record('credit_score')}n"
                f"Debt-to-Income Ratio: {record('debt_to_income_ratio')}n"
                f"Loan Type Requested: {record('loan_type')}n"
                f"Requested Amount: {record('requested_amount')}n"
                f"Financial Notes: {record('notes')}"
            )
            return {"applicant_summary": summary}
    return {"error": "Applicant record not found."}

@tool
def match_risk_policy(loan_type: str, risk_category: str) -> dict:
    """
    Match a given loan type and risk category to the most relevant risk policy rule.

    Args:
        loan_type (str): The loan product being requested.
        risk_category (str): The evaluated applicant risk category.

    Returns:
        dict: A summary of the best matching policy if found, or a message indicating no match.
    """
    context = "n".join((
        f"{i+1}. Loan Type: {p('loan_type')}, Risk Category: {p('risk_category')}, "
        f"Required Conditions: {p('required_conditions')}, Notes: {p('notes')}"
        for i, p in enumerate(risk_policies)
    ))

    prompt = f"""You are a financial risk reviewer assessing whether a loan request aligns with existing lending risk policies.

Instructions:

- Analyze the loan type and applicant risk category.
- Compare against the list of provided risk policy rules.
- Select the policy that best fits the case considering loan type and risk level.
- If none match, respond: "No appropriate risk policy found for this case."
- If a match is found, summarize the matching policy clearly including any required financial conditions or caveats.

Loan Case:

- Loan Type: {loan_type}
- Risk Category: {risk_category}

Available Risk Policies:

{context}
"""

    result = llm.invoke(prompt).text
    return {"matched_policy": result}

@tool
def check_policy_validity(
    financial_indicators: list(str),
    required_conditions: list(str),
    notes: str
) -> dict:
    """
    Determine whether the applicant financial profile satisfies policy eligibility criteria.

    Args:
        financial_indicators (list(str)): Financial indicators derived from applicant record.
        required_conditions (list(str)): Conditions required by matched policy.
        notes (str): Additional financial or employment context.

    Returns:
        dict: A string explaining whether the loan request is financially justified.
    """
    prompt = f"""You are validating a loan request based on documented financial indicators and policy criteria.

Instructions:

- Assess whether the applicant financial indicators and notes satisfy the required policy conditions.
- Consider financial context nuances.
- Provide a reasoned judgment if the loan is financially justified.
- If not qualified, explain exactly which criteria are unmet.

Input:

- Applicant Financial Indicators: {financial_indicators}
- Required Policy Conditions: {required_conditions}
- Financial Notes: {notes}
"""

    result = llm.invoke(prompt).text
    return {"validity_result": result}

@tool
def recommend_loan_action(risk_category: str) -> dict:
    """
    Recommend next lending step based on applicant risk category.

    Args:
        risk_category (str): The evaluated applicant risk level.

    Returns:
        dict: Lending recommendation string or fallback if no match found.
    """
    options = "n".join((
        f"{i+1}. Risk Category: {r('risk_category')}, Recommendation: {r('next_step')}"
        for i, r in enumerate(loan_recommendations)
    ))

    prompt = f"""You are a financial lending decision assistant suggesting next steps for a given applicant risk category.

Instructions:

- Analyze the provided risk category.
- Choose the closest match from known lending recommendations.
- Explain why the match is appropriate.
- If no suitable recommendation exists, return: "No lending recommendation found for this risk category."

Risk Category Provided:

{risk_category}

Available Lending Recommendations:

{options}
"""

    result = llm.invoke(prompt).text
    return {"recommendation": result}

Paso 6: Implementación de los subagentes (los trabajadores)

Ahora formamos nuestros tres agentes especiales. Cada agente recibe un mensaje de sistema extremadamente pequeño que le explica qué debe hacer y a qué herramientas puede aceptar, así como cómo disponer su salida.

case_intake_agent = create_agent(
    model=llm,
    tools=(fetch_applicant_record),
    system_prompt=r"""
You are a Financial Case Intake Specialist.

THIS IS A RULED TASK. FOLLOW THE STEPS IN ORDER. DO NOT SKIP STEPS.

--- MANDATORY EXECUTION RULES ---

- You MUST call the `fetch_applicant_record` tool before writing ANY analysis or summary.
- If you do not have applicant data from the tool, you MUST stop and say: "Applicant data not available."
- Do NOT hallucinate, infer, or invent financial facts beyond what is provided.
- Inference is allowed ONLY when logically derived from financial notes.

--- STEP 1: DATA ACQUISITION (REQUIRED) ---

Call `fetch_applicant_record` and read:

- Financial indicators
- Financial profile / risk context
- Loan request
- Financial notes

You may NOT proceed without this step.

--- STEP 2: FINANCIAL ANALYSIS ---

Using ONLY the retrieved data:

1. Summarize the applicant financial case.
2. Identify explicit financial indicators.
3. Identify inferred financial risks (label as "inferred").
4. Derive rationale for why the loan may have been requested.

--- STEP 3: VALIDATION CHECK ---

Before finalizing, confirm:

- No financial facts were added beyond tool output.
- Inferences are financially reasonable.
- Summary is indeterminado and review-ready.

--- FINAL OUTPUT FORMAT (STRICT) ---

Sub-Agent Name: Case Intake Agent

Financial Summary:

- ...

Key Financial Indicators:

- Explicit:
  - ...
- Inferred:
  - ...

Financial Rationale for Loan Request:

- ...

If any section cannot be completed due to missing data, state that explicitly.
"""
)

lending_decision_agent = create_agent(
    model=llm,
    tools=(recommend_loan_action),
    system_prompt=r"""
You are a Lending Decision Recommendation Specialist.

YOU MUST RESPECT PRIOR AGENT DECISIONS.

--- NON-NEGOTIABLE RULES ---

- You MUST read Intake Agent and Risk Policy Checker outputs first.
- You MUST NOT override or contradict the Risk Policy Checker.
- You MUST clearly state whether loan request was:
  - Approved
  - Not Approved
  - Not Validated

--- STEP 1: CONTEXT REVIEW ---

Identify:

- Confirmed financial profile / risk category
- Policy decision outcome
- Key financial risks and constraints

--- STEP 2: DECISION-AWARE PLANNING ---

IF loan request APPROVED:

- Recommend next lending execution steps.

IF loan request NOT APPROVED:

- Do NOT recommend approval.
- Suggest ONLY:
  - Additional financial documentation
  - Risk mitigation steps
  - Financial profile improvement suggestions
  - Monitoring or reassessment steps

IF policy NOT FOUND:

- Recommend cautious next steps and documentation improvement.

--- STEP 3: SAFETY CHECK ---

Before finalizing:

- Ensure recommendation does not contradict policy outcome.
- Ensure all suggestions are financially reasonable.

--- FINAL OUTPUT FORMAT (STRICT) ---

Sub-Agent Name: Lending Decision Agent

Policy Status:

- Approved / Not Approved / Not Found

Lending Recommendations:

- ...

Rationale:

- ...

Notes for Reviewer:

- ...

Avoid speculative financial approvals.
Avoid recommending approval if policy validation failed.
"""
)

risk_policy_checker_agent = create_agent(
    model=llm,
    tools=(match_risk_policy, check_policy_validity),
    system_prompt=r"""
You are a Lending Risk Policy Review Specialist.

THIS TASK HAS HARD CONSTRAINTS. FOLLOW THEM EXACTLY.

--- MANDATORY RULES ---

- You MUST pulvínulo decisions only on:
  1. Intake summary content
  2. Retrieved risk policy rules
- You MUST NOT approve or reject without a policy check attempt.
- If no policy exists, you MUST explicitly state that.
- Do NOT infer policy eligibility criteria.

--- STEP 1: POLICY IDENTIFICATION (REQUIRED) ---

Use `match_risk_policy` to identify the most relevant policy for:

- The requested loan type
- The evaluated risk category

If no policy is found:

- STOP further validation
- Clearly state that no applicable policy exists

--- STEP 2: CRITERIA EXTRACTION ---

If a policy is found:

- Extract REQUIRED financial conditions exactly as stated
- Do NOT paraphrase eligibility criteria

--- STEP 3: VALIDATION CHECK (REQUIRED) ---

Use `check_policy_validity` with:

- Applicant financial indicators
- Policy required conditions
- Intake financial notes

--- STEP 4: REASONED DECISION ---

Based ONLY on validation result:

- If criteria met → justify approval
- If criteria not met → explain why
- If insufficient data → state insufficiency

--- FINAL OUTPUT FORMAT (STRICT) ---

Sub-Agent Name: Risk Policy Checker Agent

Risk Policy Identified:

- Name:
- Source (if available):

Required Policy Conditions:

- ...

Applicant Evidence:

- ...

Policy Validation Result:

- Met / Not Met / Insufficient Data

Financial Justification:

- ...

Do NOT recommend lending actions here.
Do NOT assume approval unless criteria are met.
"""
)

Paso 7: The Mastermind – Implementación del Agente Supervisor

Este es el núcleo de nuestro sistema. Su constitución es la indicación del supervisor. Establece el orden rígido del flujo de trabajo y los controles de calidad que debe realizar sobre la producción de cada agente ayer de continuar.

class State(TypedDict):
    messages: Annotated(list, add_messages)

members = (
    "case_intake_agent",
    "risk_policy_checker_agent",
    "lending_decision_agent"
)

SUPERVISOR_PROMPT = f"""
You are a Loan Review Supervisor Agent.
You are managing a STRICT, ORDERED loan risk review workflow
between the following agents:

{members}

--- WORKFLOW ORDER (MANDATORY) ---

1. case_intake_agent
2. risk_policy_checker_agent
3. lending_decision_agent
4. FINISH

You MUST follow this order. No agent may be skipped.

--- YOUR RESPONSIBILITIES ---

1. Read all messages so far carefully.
2. Determine which agents have already executed.
3. Inspect the MOST RECENT output of each executed agent.
4. Decide which agent MUST act next based on completeness and order.

--- COMPLETENESS REQUIREMENTS ---

Before moving to the next agent, verify the previous agent’s output contains:

case_intake_agent output MUST include:
- "Financial Summary"
- "Key Financial Indicators"
- "Financial Rationale"

risk_policy_checker_agent output MUST include:
- "Policy Validation Result"
- "Financial Justification"
- Either a policy match OR explicit statement no policy exists

lending_decision_agent output MUST include:
- "Policy Status"
- "Lending Recommendations"
- Clear approval / non-approval status

--- ROUTING RULES ---

- If an agent has NOT run yet → route to that agent.
- If an agent ran but required sections missing → route SAME agent again.
- ONLY return FINISH if all three agents completed correctly.
- NEVER return FINISH early.

--- RESPONSE FORMAT ---

Return ONLY one of:

{members + ("FINISH")}
"""

FINAL_RESPONSE_PROMPT = """
You are the Loan Review Supervisor Agent.

Analyze ALL prior agent outputs carefully.

--- CRITICAL DECISION RULE ---

Your Final Decision MUST be based PURELY on the output of the
lending_decision_agent.

- If lending_decision_agent indicates loan APPROVED
  → Final Decision = APPROVED
- If lending_decision_agent indicates NOT APPROVED or NEEDS INFO
  → Final Decision = NEEDS REVIEW

--- OUTPUT FORMAT (STRICT) ---

- Agent Name: Loan Review Supervisor Agent
- Final Decision: APPROVED or NEEDS REVIEW
- Decision Reasoning: Based on lending_decision_agent output
- Lending recommendation or alternative steps: From lending_decision_agent
"""

class Router(TypedDict):
    next: Igual(
        "case_intake_agent",
        "risk_policy_checker_agent",
        "lending_decision_agent",
        "FINISH"
    )

def supervisor_node(state: State) -> Command(
    Igual(
        "case_intake_agent",
        "risk_policy_checker_agent",
        "lending_decision_agent",
        "__end__"
    )
):
    messages = (SystemMessage(content=SUPERVISOR_PROMPT)) + state("messages")
    response = llm.with_structured_output(Router).invoke(messages)
    goto = response("next")

    if goto == "FINISH":
        goto = END
        messages = (SystemMessage(content=FINAL_RESPONSE_PROMPT)) + state("messages")
        response = llm.invoke(messages)
        return Command(
            goto=goto,
            update={
                "messages": (
                    AIMessage(
                        content=response.text,
                        name="supervisor"
                    )
                ),
                "next": goto
            }
        )

    return Command(goto=goto, update={"next": goto})

Paso 8: Detallar las funciones del nodo

Aquí se definirán las funciones de los nodos que desempeñarán el papel de nodos de laggraph.

def case_intake_node(state: State) -> Command(Igual("supervisor")):
    result = case_intake_agent.invoke(state)
    return Command(
        update={
            "messages": (
                AIMessage(
                    content=result("messages")(-1).text,
                    name="case_intake_agent"
                )
            )
        },
        goto="supervisor"
    )

def risk_policy_checker_node(state: State) -> Command(Igual("supervisor")):
    result = risk_policy_checker_agent.invoke(state)
    return Command(
        update={
            "messages": (
                AIMessage(
                    content=result("messages")(-1).text,
                    name="risk_policy_checker_agent"
                )
            )
        },
        goto="supervisor"
    )

def lending_decision_node(state: State) -> Command(Igual("supervisor")):
    result = lending_decision_agent.invoke(state)
    return Command(
        update={
            "messages": (
                AIMessage(
                    content=result("messages")(-1).text,
                    name="lending_decision_agent"
                )
            )
        },
        goto="supervisor"
    )

Paso 9: construir y visualizar el representación

Ahora que hemos definido nuestros nodos, podemos construir el representación de flujo de trabajo. Se define el punto de entrada, los nodos de cada agente y aristas condicionales que dirigen el flujo de trabajo en función de la valor del supervisor.

graph_builder = StateGraph(State)
graph_builder.add_edge(START, "supervisor")
graph_builder.add_node("supervisor", supervisor_node)
graph_builder.add_node("case_intake_agent", case_intake_node)
graph_builder.add_node("risk_policy_checker_agent", risk_policy_checker_node)
graph_builder.add_node("lending_decision_agent", lending_decision_node)
loan_multi_agent = graph_builder.compile()
loan_multi_agent

Puedes visualizar el representación si tienes las bibliotecas adecuadas, pero procederemos a ejecutarlo.

Paso 10: ejecutar el sistema

Ahora llega el momento de la verdad. Nos postularemos como solicitantes a nuestro sistema y seguiremos al supervisor para organizar el proceso de revisión. Antiguamente de esto, descargaremos una función de utilidad para formatear la salida.

# This utility file is not essential to the logic but helps format the streaming output nicely.
!gdown 1dSyjcjlFoZpYEqv4P9Oi0-kU2gIoolMB

from agent_utils import format_message

def call_agent_system(agent, prompt, verbose=False):
    events = agent.stream(
        {"messages": (("user", prompt))},
        {"recursion_limit": 25},
        stream_mode="values"
    )
    for event in events:
        if verbose:
            format_message(event("messages")(-1))

    # Display the final response from the agent as Markdown
    print("nnFinal Response:n")
    if event("messages")(-1).text:
        display(Markdown(event("messages")(-1).text))
    else:
        print(event("messages")(-1).content)

    # Return the overall event messages for optional downstream use
    return event("messages")

prompt = "Review applicant A101 for loan approval justification."
call_agent_system(loan_multi_agent, prompt, verbose=True)

Examen de salida:

Cuando ejecute esto, verá un seguimiento de ejecución paso a paso:

1. supervisor (al agente de admisión de casos): El supervisor inicia el proceso dirigiendo la tarea al agente de admisión.
2. caseintakeagent Salida: Es un agente que ejecutará su útil para recuperar el registro del solicitante A101 y difundir un breviario financiero noble.

3. supervisor -> agente de control de política de peligro: El supervisor se da cuenta de que se ha realizado la admisión y envía la tarea al verificador de políticas.
4. Salida de Riskpolicycheckeragent: El agente de pólizas descubrirá que la A101 es una póliza de bajo peligro que satisface todos los requisitos del perfil de un préstamo hipotecario.

5. supervisor -> agente de valor de préstamo: El supervisor ahora instiga a quien toma las decisiones en última instancia.
6. agente de valor de préstamo Salida: Este agente recomendará una aprobación cibernética en la categoría de “Bajo Aventura”.

7. supervisor -> FINALIZAR: Cuando el supervisor llega FINALIZARmanejo al trabajador final como completo y produce un breviario acumulativo.

El producto final será un mensaje proporcionadamente escrito y dispensado de suciedad como:

Cuaderno de colaboración: Agentes supervisores de masterización.ipynb

Conclusión

Utilizando un agente supervisor, transformamos un proceso comercial complicado en un flujo de trabajo predecible, sólido y auditable. Incluso un agente que intentara ocuparse de la recuperación de datos, el exploración de riesgos y la toma de decisiones simultáneamente necesitaría un mensaje mucho más complicado y sería mucho más probable que cometiera un error.

El patrón de supervisor ofrece un maniquí mental sólido y un enfoque arquitectónico para desarrollar sistemas avanzados de IA. Le permite deconstruir la complejidad y asignar responsabilidades distintas y crear flujos de trabajo inteligentes y automatizados que se asemejan a la poder de un equipo humano proporcionadamente coordinado. La segunda forma de acometer un desafío monolítico es no simplemente crear un agente la próxima vez, sino un equipo y tener siempre un supervisor.

Preguntas frecuentes

Harsh Mishra es un ingeniero de IA/ML que pasa más tiempo hablando con modelos de habla grandes que con humanos reales. Apasionado por GenAI, PNL y hacer que las máquinas sean más inteligentes (para que no lo reemplacen todavía). Cuando no optimiza modelos, probablemente esté optimizando su consumo de café. 🚀☕