Para las grandes empresas, cada vez más organizaciones están adoptando agentes de IA y arquitecturas de múltiples agentes para ofrecer soluciones confiables, escalables y manejables. Los costos de los agentes de IA y LLM pueden dispararse rápidamente sin una gestión cuidadosa. En esta publicación, descubriremos varios problemas comerciales de planificación de agentes y optimización de costos y los enmarcaremos como soluciones de investigación de operaciones a través de la lente de la ciencia de datos. Si está interesado en obtener más información sobre la planificación de agentes y la IA agente, consulte mi artículo sobre "Cómo construir su propio sistema de IA agente usando CrewAI".
¿Qué es la optimización en la investigación de operaciones?
La investigación de operaciones aprovecha los modelos matemáticos y la optimización para encontrar la mejor decisión bajo restricciones prácticas. Es la columna vertebral del análisis prescriptivo, que transforma los conocimientos predictivos en acciones críticas para la toma de decisiones. Enmarcar una situación del mundo real en un modelo matemático abstracto es la clave para resolver cualquier problema de investigación de operaciones.
Un ejemplo simple pero ampliamente mencionado de investigación de operaciones es el problema de programación lineal, donde tratamos de encontrar valores de x e y que maximicen una ecuación lineal (por ejemplo, 2x + 4y), sujeto a las restricciones x ≥ 0 e y ≥ 0. Los problemas de investigación de operaciones generalmente incluyen los siguientes componentes clave:
Variables de Decisión: Las variables a determinar. Restricciones: Las limitaciones del mundo real sobre recursos o requisitos. Objetivos: La meta a maximizar o minimizar.
Cómo optimizar el costo de los agentes y la asignación de recursos
La planificación de agentes de IA implica tomar decisiones de asignación de recursos dentro del presupuesto de una empresa y al mismo tiempo lograr los mejores resultados posibles, lo que la hace ideal para escenarios de investigación de operaciones. Podemos asignar los componentes principales anteriores a casos de uso de optimización de costos de agentes y planificación de recursos.
Variables de decisión: Los agentes asignan tareas o proyectos Restricciones: presupuesto, tiempo de respuesta, token Objetivos: minimizar costos, maximizar el retorno de la inversión
Usaremos los 4 patrones de optimización más estándar para abordar escenarios comunes de planificación de agentes:
Problema de cobertura de conjuntos: elija el conjunto más pequeño de agentes para cubrir todas las tareas, habilidades o funciones comerciales requeridas, con el objetivo de minimizar costos sin dejar brechas en la capacidad. Problema de asignación: decidir qué agente debe manejar cada proyecto, con el objetivo de maximizar el valor de producción general. Problema de mochila: seleccione el mejor conjunto de agentes con un presupuesto fijo para maximizar los tokens de producción total. Problema de red: Diseñe flujos de trabajo a través de una red de agentes para satisfacer las demandas de los departamentos y usuarios al menor costo bajo limitaciones de capacidad.
Para que esto sea más práctico, veremos cuatro ejemplos en Python usando la biblioteca Gurobi. Gurobi es un solucionador de optimización matemática de nivel empresarial que admite muchos tipos de problemas, incluida la programación lineal y la programación de enteros mixtos. A menudo se utiliza como el “motor de resolución” detrás de las aplicaciones de investigación de operaciones porque puede manejar modelos a gran escala de manera eficiente y proporciona API sólidas, incluido Python, para definir variables de decisión, restricciones y funciones objetivas. Gurobi permite a los científicos de datos centrarse en modelar en lugar de implementar algoritmos de optimización personalizados. Tenga en cuenta que este artículo no está afiliado a Gurobi y que todas las funcionalidades mencionadas aquí se pueden lograr utilizando la licencia gratuita. Todos los conjuntos de datos que se muestran en este proyecto son sintéticos y se utilizan para demostrar una prueba de concepto.
1. Problema de cobertura de conjuntos: cobertura de habilidades del agente
La cobertura de conjuntos es un problema de optimización clásico que se refiere al problema de elegir el menor número de opciones para que cada elemento requerido quede cubierto al menos una vez. Un escenario común de optimización de costos de agentes de IA que se ajusta al problema de cobertura de conjuntos es la cobertura de habilidades, donde nuestro objetivo es identificar la cantidad mínima de agentes necesarios para cubrir las habilidades fundamentales requeridas para respaldar las operaciones diarias de la empresa.
Planteamiento del problema: La empresa quiere incorporar agentes a las operaciones diarias y cubrir las nueve áreas de habilidades enumeradas en la tabla "Área de habilidades" a continuación. Construir cada agente cuesta $ 20 mil y se especializa en un conjunto distinto de habilidades, como se muestra en la tabla "Habilidades del agente". ¿Cómo puede la empresa minimizar el costo total de los agentes de construcción y al mismo tiempo cubrir todas las áreas?
Área de habilidades
Habilidad del agente
Implementación
Podemos enmarcarlo como un problema de optimización que sigue el patrón de cobertura de conjuntos y resolverlo utilizando la biblioteca Gurobi, definida por los siguientes componentes clave: datos, modelo, variables, restricciones y objetivos.
Datos: cargue los datos de habilidades, agentes y costos de agentes (que son 20k cada agente) ## datos habilidades = datos["skills"] agentes = datos["agents"] agent_skills = datos["agent_skills"] agent_costs = {i: 20 for i in agentes} Modelo: cree el modelo Gurobi con el nombre “Set Covering”. Si aún no ha instalado gurobipy, ejecute el comando ## model import gurobipy as gp model = gp.Model("Set Covering") Variables: Las variables de decisión son variables binarias asociadas con cada agente, con un límite inferior de 0 y un límite superior de 1 para indicar si se selecciona un agente. Gurobi ofrece una variedad de tipos de variables preestablecidas, que incluyen GRB.BINARY, GRB.INTEGER y GRB.CONTINUOUS, etc. ## variables X = model.addVars(agents, lb=0, ub=1, vtype=GRB.BINARY, name="x") Restricciones: Para cada área de habilidad, la suma de todos los agentes seleccionados con esa habilidad debe ser superior a 1, lo que garantiza que tengamos al menos un agente para cubrir el área de habilidad. Usamos la función de suma gp.quicksum para agregar restricciones usando suma ponderada y luego usamos expresiones de bucle anidado para iterar a través de nueve áreas de habilidades. ## restricciones: para cada habilidad en habilidades, suma de agentes con esa habilidad ≥ 1 para j en habilidades: model.addConstr( gp.quicksum(X[i] para i en agentes si j en agente_skills[i]) >= 1, nombre=f'{j}_area_constr' ) Objetivo: Minimizar el costo total de los agentes seleccionados, calculado como la suma ponderada del costo de cada agente multiplicada por la variable de decisión que indica si ese agente es seleccionado. ## objetivos: minimizar la suma de los agentes seleccionados model.setObjective( gp.quicksum(agent_costs[i] * X[i] para i en agentes), GRB.MINIMIZE )
Por último, ejecutamos la optimización del modelo usando model.optimize().
Impacto empresarial
En esta sección, primero interpretamos el resultado óptimo del modelo y luego estimamos el impacto de tomar decisiones basadas en ese resultado óptimo versus tomar decisiones aleatorias. En un entorno empresarial, esto ayuda a los líderes a asignar el presupuesto de manera efectiva al determinar qué agentes crear, implementar o retirar.
Resultado óptimo
model.ObjVal imprime el valor objetivo óptimo. Para cada variable de decisión binaria, utilizamos X[i].X > 0,5 para imprimir los agentes seleccionados.
print(f"Total de agentes seleccionados: {ronda(model.ObjVal, 4)}") para i en agentes: si X[i].X > 0.5: print(f"Agente {i} seleccionado.")
Alternativamente, Claude Code me sugiere el siguiente fragmento para mostrar el resultado del modelo de manera estructurada.
print("================ Cobertura de conjunto: Cobertura de habilidades ================") if model.Status == GRB.OPTIMAL: seleccionado = [i para i en agentes si X[i].X > 0.5] print(f"Agentes mínimos necesarios: {len(seleccionado)}") print(f"Costo total: ${model.ObjVal:.0f}k") print("nAgentes seleccionados:") para el agente en seleccionado: cubierto = ", ".join( f"{s}({skill_labels[s]})" para s en agente_skills[agente] ) print(f" – {agente} [{cubierto}]") else: print("No se encontró una solución óptima.")
El resultado a continuación muestra que la planificación óptima de agentes es seleccionar 4 agentes (Agente de soporte general, Agente de acceso y permisos, Agente de CRM y Agente de optimización de costos y rendimiento) para cubrir todas las habilidades con un gasto de presupuesto de $80 mil.
================ Cobertura del conjunto: Cobertura de habilidades ================ Agentes mínimos necesarios: 4 Costo total: $80 000 Agentes seleccionados: – Agente de soporte general [F (Soporte), C (Conocimiento), H (Colaboración)] – Agente de acceso y permisos [F (Soporte), E (Automatización), G (Gobernanza)] – CRM / Agente de gestión de relaciones [A(Planificación), B(Uso de herramientas), C(Conocimiento)] – Agente de optimización de costos y rendimiento [D(Análisis), I(Monitoreo), J(Optimización)]
Simulaciones
Luego simulamos selecciones aleatorias y las comparamos con el resultado óptimo. Como se muestra a continuación, generamos 500 selecciones de agentes factibles (histograma azul) con costos que oscilan entre $ 80 000 y $ 200 000 y un costo promedio de $ 134,6 000 (línea de puntos azul). Esto significa que la optimización ayuda a la empresa a reducir el costo en ($134,6k − $80k)/$134,6 = 40,6% en promedio.
───────────────────────── ───────────────────────── Cobertura de conjuntos: cobertura de habilidades ───────────────────────── ───────────────────────── Mínimo (óptimo): 80,00 k$ Sim media: 132,88 k$ Sim min: 80,00 k$ Sim max: 220,00 k$ Soluciones factibles: 500/500 ───────────────────────── ─────────────────────────
Explore la implementación completa en nuestro repositorio de GitHub.
2. Problema de asignación: asignación de recursos del agente
El problema de asignación sigue un patrón común para relacionar tareas con personas u objetos, generalmente una relación de uno a uno o de uno a muchos, para maximizar la producción producida o minimizar los costos. La asignación de recursos de agentes se ajusta a este patrón de problema, ya que requiere asignar un conjunto de agentes entre proyectos, generalmente con la restricción de que a cada proyecto se le asigne un agente principal y el objetivo de lograr el valor de producción total más alto.
Planteamiento del problema: La empresa ha creado un conjunto de agentes para trabajar en 9 proyectos y cada proyecto requiere asignar un agente principal. La siguiente tabla muestra cuánto valor puede aportar cada agente a cada proyecto. ¿Cómo puede la empresa maximizar el valor global asignando al agente principal más adecuado a los proyectos?
Implementación
Seguimos el mismo proceso de seis pasos para resolver este problema de asignación.
Datos: carga los datos de agentes, proyectos y valores. Cree un diccionario value_map para representar la relación entre el agente y el proyecto. ## agentes de datos = datos["agentes"] proyectos = datos["proyectos"] valores = datos["valores"] # Generar búsqueda de valores: (agente, proyecto) -> puntuación value_map = { (agentes[i], proyectos[j]): valores[i][j] para i en rango(len(agentes)) para j en rango(len(proyectos)) } Modelo: cree un modelo Gurobi con el nombre “Asignación”. ## model import gurobipy as gp model = gp.Model("Assignment") Variables: las variables de decisión en este problema deben indicar si un agente está asignado a un proyecto, que es una variable binaria asociada con cada combinación única de agente y proyecto. ## variables de gurobipy import GRB X = model.addVars(agents, proyectos, lb=0, ub=1, vtype=GRB.BINARY, name="x") Restricciones: Para cada proyecto, la suma de todos los agentes asignados debe ser exactamente uno. Para cada agente, la suma de los proyectos a los que está asignado debe ser al menos uno. ## restricciones: a cada proyecto se le asigna exactamente un agente para j en proyectos: model.addConstr( gp.quicksum(X[(i, j)] para i en agentes) == 1, name=f"{j}_project_constr", ) ## restricciones: a cada agente se le asigna al menos un proyecto para i en agentes: model.addConstr( gp.quicksum(X[(i, j)] para j en proyectos) >= 1, name=f"{i}_agent_constr", ) Objetivo: Maximizar la puntuación del valor general utilizando la suma de la puntuación de cada agente en cada proyecto multiplicada por la variable de decisión que indica si el agente está asignado al proyecto. ## objetivo: maximizar la puntuación de valor general model.setObjective( gp.quicksum(value_map[(i, j)] * X[(i, j)] for i en agentes para j en proyectos), GRB.MAXIMIZE,)
Impacto empresarial
Al enmarcar la asignación de agentes como un problema de asignación, las empresas pueden asignar agentes a proyectos de la manera que mejor se adapte a sus habilidades y maximice el valor general. Esto mejora el retorno de la inversión al aumentar la calidad de la producción y al mismo tiempo lograr los objetivos comerciales con el mismo conjunto de agentes prediseñados.
Para comprender el impacto empresarial de este escenario de optimización, primero interpretaremos la asignación recomendada después de ejecutar model.optimize() y luego estimaremos el impacto en la puntuación de valor general comparando el resultado óptimo con asignaciones aleatorias.
Resultado óptimo
model.ObjVal imprime el valor objetivo óptimo. Para cada variable binaria que indica la asignación del agente, utilizamos X[i, j].X > 0,5 para examinar si el agente i está asignado al proyecto j.
print(f"Valor total: {round(model.ObjVal, 4)}") para i en agentes: para j en proyectos: si X[(i, j)].X > 0.5: print(f"El agente {i} debe asignarse al proyecto {j}.")
O utilice el siguiente fragmento para mostrar el resultado del modelo de forma más detallada.
print("================ Problema de asignación: Asignación de recursos ================") if model.Status == GRB.OPTIMAL: print(f"Puntuación máxima de idoneidad total: {model.ObjVal:.0f}n") print(f"{'Agente':<45} {'Proyecto':<6} {'Descripción':<30} {'Puntuación'}") print("-" * 95) para i en agentes: para j en proyectos: if X[(i, j)].X > 0.5: print( f"{i:<45} {j:<6} {project_labels[j]:<30} {obj_coeffs[(i, j)]}"
El siguiente resultado muestra la asignación óptima de recursos, que asigna un agente principal a cada proyecto y logra una puntuación total de idoneidad de 77.
================ Problema de asignación: Asignación de recursos ================ Puntuación máxima de idoneidad total: 77 Puntuación de descripción del proyecto del agente ———————————————————————————————– Agente de análisis e información P1 Panel de métricas ejecutivas 9 Agente de análisis e información P7 Monitor de riesgo de abandono 8 Agente de gestión del conocimiento P8 Guía de incorporación Bot 9 Agente de orquestación de campañas de marketing P3 Modelo de puntuación de clientes potenciales 9 Agente de orquestación de campañas de marketing P6 Resumen de lanzamiento de funciones 8 Agente de automatización de atención al cliente P2 CX Knowledge Bot 9 Agente de monitoreo y calidad de datos P9 Clasificación de incidentes de SLA 8 Agente de orquestación de flujo de trabajo P5 Análisis de experimentos 8 Agente de gobierno y cumplimiento P4 Asistente de control de calidad de políticas 9
Simulaciones
Simulamos 500 asignaciones de agentes factibles y aleatorias y las comparamos con el resultado óptimo, donde la puntuación de valor es 77. Como se muestra a continuación, las 500 asignaciones factibles produjeron puntuaciones de valor generales que oscilaron entre 55 y 72, con una puntuación de valor media de 63,16. Esto indica que la optimización mejora las puntuaciones de valor en (77 − 63,16) / 63,16 = 21,9% en promedio.
───────────────────────── ───────────────────────── Asignación: Asignación de agente a proyecto ───────────────────────── ───────────────────────── Máximo (óptimo): 77,00 puntuación Sim media: 63,16 puntuación Sim min: 55,00 puntuación Sim máx: 72,00 puntuación Soluciones factibles: 500/500 ───────────────────────── ─────────────────────────
3. Problema de la mochila: presupuesto de los agentes
El problema de la mochila es un escenario de optimización en el que elegimos la mejor combinación de elementos mientras nos mantenemos dentro de un límite, como un presupuesto o una restricción de capacidad. La gestión de carteras y los arreglos logísticos son implicaciones populares en el mundo real. Es adecuado para escenarios de asignación de presupuesto de agentes en los que necesitamos maximizar la producción del agente con un presupuesto de empresa limitado.
Planteamiento del problema: Dado un presupuesto mensual de $4000, seleccione agentes de la lista siguiente, cada uno con un costo mensual fijo, para maximizar el total de tokens generados.
Implementación
Nuevamente, utilice el proceso de 6 pasos para solucionar este problema de mochila.
Datos: cargue la lista de agentes, el costo mensual de cada agente y la producción de tokens de cada agente, junto con un presupuesto mensual fijo de $4,000. ## datos agentes = datos["agentes"] N = rango(len(agentes)) # número de agentes C = datos["costes"] # costo por agente P = datos["tokens"] # tokens por agente K = 4000 # $4000 de presupuesto mensual Modelo: Crear un modelo Gurobi con el nombre “Knapsack”. ## model import gurobipy as gp model = gp.Model("Knapsack") Variables: una variable de decisión binaria está asociada con cada agente para indicar si están seleccionados. ## variables X = model.addVars(N, lb=0, ub=1, vtype=GRB.BINARY, name="x") Restricciones: los costos totales de todos los agentes seleccionados no deben exceder el presupuesto K. ## restricción: el costo total no debe exceder el presupuesto model.addConstr( gp.quicksum(C[i] * X[i] for i in N) <= K, name="budget_constr", ) Objetivo: Maximizar el Número total de tokens generados por todos los agentes seleccionados. ## objetivo: maximizar el total de tokens generados model.setObjective( gp.quicksum(C[i] * X[i] for i in N), GRD.MAXIMIZE,)
Impacto empresarial
Este tipo de problema de optimización se utiliza ampliamente en las empresas porque ayuda a maximizar la producción con un presupuesto fijo. Compararemos los resultados optimizados con 500 selecciones aleatorias de agentes bajo las mismas restricciones presupuestarias.
Resultado óptimo
Después de ejecutar model.optimize(), usamos model.ObjVal para obtener el valor objetivo óptimo del total de tokens generados. Para cada variable de decisión binaria, utilizamos X[i].X > 0,5 para comprobar si se selecciona el agente i.
print(f"Total de tokens generados: {ronda(model.ObjVal, 4)}") para el agente en N: si X[agente].X > 0.5: print(f"Agente {agente} seleccionado.")
El resultado del modelo sugiere seleccionar 4 agentes (Clasificador de intención, Verificador de inventario, Analizador de revisión y Reportero de análisis) que nos permitan generar la cantidad máxima de tokens (por ejemplo, 215 millones de tokens) dentro del presupuesto mensual de $4000.
================ Problema de mochila: Presupuesto ================ Presupuesto: $4000 Costo total utilizado: $4000 Total de tokens (M): 215 Costo del agente ($) Tokens (M) ——————————————————- Clasificador de intención 800 50 Comprobador de inventario 1200 70 Analizador de revisión 900 45 Reportero de análisis 1100 50 —————————————————— TOTAL 4000 215
Simulaciones
Simulamos 500 asignaciones de agentes factibles y aleatorias con el mismo presupuesto de 4000 dólares y las comparamos con el resultado óptimo de 215 millones de tokens. En estas simulaciones, el total de tokens osciló entre 50 millones y 215 millones, con un promedio de 151,61 millones, lo que muestra que el plan optimizado funciona aproximadamente (215 − 151,61) / 151,61 = 41,8 % mejor que la asignación aleatoria promedio.
───────────────────────── ───────────────────────── Mochila: selección del presupuesto del agente ───────────────────────── ───────────────────────── Máximo (óptimo): 215,00 tokens (M) Sim media: 151,61 tokens (M) Sim min: 50,00 tokens (M) Sim max: 215,00 tokens (M) Soluciones factibles: 500/500 ───────────────────────── ─────────────────────────
4. Problema de red: enrutamiento del agente
Por último, discutiremos el problema de la red, que aborda escenarios que requieren equilibrar la oferta y la demanda, o entradas y salidas en un conjunto de entidades. Por ejemplo, implica mover inventarios a través de una red de almacenes al menor costo respetando la capacidad de envío. Un gráfico acíclico dirigido (DAG) es un modelo gráfico común para problemas de red, donde los nodos representan entidades distintas y los arcos representan flujos desde una entidad de entrada a una entidad de salida. Una restricción crítica en un problema de red es que cada nodo cumpla con el requisito de “oferta + entrada = demanda + salida”, por lo que el flujo neto es igual a la demanda menos la oferta.
El enrutamiento de agentes y la orquestación de múltiples agentes se ajustan a este patrón porque coordinan múltiples agentes a través de una secuencia de entradas y salidas y requieren diseñar un flujo de trabajo que equilibre la demanda del usuario con la capacidad disponible de cada agente. A medida que crece la demanda de flujos de trabajo de múltiples agentes, este dominio ofrece más oportunidades para optimizar la eficiencia de la colaboración y el consumo de recursos.
Planteamiento del problema: una empresa tiene una arquitectura de múltiples agentes que incluye un agente de codificación y un agente de escritura, junto con dos centros de agentes que sirven como coordinadores. Cada uno de los departamentos de TI, marketing y operaciones requiere que se cumpla una cierta cantidad de solicitudes cada mes, como se muestra en la siguiente tabla. Si bien los departamentos pueden comunicarse directamente con los dos agentes, esto normalmente genera un costo más alto por solicitud. Enrutar las solicitudes a través de los centros de agentes reduce los costos al estandarizar el protocolo de comunicación. Cada enlace también tiene una capacidad máxima de solicitudes mensuales, como se detalla en la siguiente tabla. ¿Cuál es la forma más rentable de enrutar 12 000 solicitudes de tareas del agente de codificación y del agente de redacción a los departamentos de marketing, TI y operaciones?
Oferta y demanda
Costo/capacidad de enrutamiento
Implementación
Datos: cargue los datos de las capacidades de suministro de los agentes y las demandas de solicitudes de los departamentos, junto con el costo y la capacidad de cada arco que fluye desde un agente a un centro o directamente a un departamento. ## nodos de datos = datos["nodos"] suministros = datos["suministros"] demandas = datos["demanda"] arcos = [(a, b) para a, b, _, __ en datos["arcos"]] costos = {(a, b): c para a, b, c, __ en datos["arcos"]} capacidades = {(a, b): límite para a, b, _, límite en datos["arcos"]} Modelo: Crea un modelo Gurobi con el nombre “Red”. ## model import gurobipy as gp model = gp.Model("Network") Variables: defina una variable continua para cada arco para representar el número de solicitudes que fluyen de un nodo a otro, con un límite superior igual a la capacidad del arco. ## variables X = model.addVars(arcs, lb=0, ub=capacities, vtype=GRB.CONTINUOUS, name="x") Restricciones: Para cada nodo (incluidos agentes, centros de agentes y departamentos), la suma de las solicitudes de suministro y de entrada debe ser igual a la suma de las solicitudes de demanda y de salida. ## restricciones: equilibrio de flujo en cada nodo para i en nodos: model.addConstr( suministra[i] + gp.quicksum(X[(j, i)] para j en nodos si (j, i) en arcos) == demandas[i] + gp.quicksum(X[(i, j)] para j en nodos si (i, j) en arcos), nombre=f"{i}_balance_constr", ) Objetivo: Minimice el costo total de todas las solicitudes de un agente a un centro de agentes o directamente a un departamento. ## objetivo: minimizar el costo total de enrutamiento model.setObjective( gp.quicksum(costs[(i, j)] * X[(i, j)] for i, j in arcs), GRB.MINIMIZE, )
Impacto empresarial
La optimización del enrutamiento de agentes ayuda a decidir cuántas solicitudes enviar a lo largo de cada enlace para satisfacer todas las demandas del departamento al menor costo, considerando al mismo tiempo la capacidad del flujo de trabajo y las limitaciones del sistema.
Resultado óptimo
Usamos model.ObjVal para obtener el valor objetivo óptimo para el costo total. Luego usamos X[(i,j)].X para imprimir el número de solicitudes que fluyen desde cada nodo de entrada a cada nodo de salida.
print(f"Costo total: {round(model.ObjVal, 2)}") para (i,j) en arcos: si X[(i,j)].X > 0: print(f"Enviar {X[(i,j)].X} unidades de flujo en el arco de {i} a {j}")
Como se muestra en el resultado a continuación, vemos que la solución óptima cuesta $5630 por mes para cumplir con 12 mil solicitudes exigidas por los equipos de marketing, TI y operaciones.
================ Problema de enrutamiento de red: Enrutamiento del agente ================ Costo total mínimo de enrutamiento: $5630,00 Costo límite de flujo de arco/coste total requerido ————————————————————————————- Agente de codificación -> Departamento de marketing 1500 2000 0,80 1200,00 Agente de codificación -> Departamento de TI 2000 2000 0,60 1200,00 Agente de codificación -> Departamento de operaciones 1200 1200 0,30 360,00 Agente de codificación -> Centro de retransmisión A 1200 1500 0,30 360,00 Agente de codificación -> Centro de retransmisión B 600 1200 0,20 120,00 Agente de redacción -> Departamento de marketing 2000 2000 0,50 1.000,00 Agente de escritura -> Departamento de TI 1000 1000 0,20 200,00 Agente de escritura -> Departamento de operaciones 1000 1000 0,20 200,00 Agente de escritura -> Centro de retransmisión A 300 2000 0,40 120,00 Agente de escritura -> Centro de retransmisión B 1200 1200 0,20 240,00 Centro de retransmisión A -> Departamento de marketing 1500 1500 0,30 450,00 Centro de retransmisión B -> Departamento de TI 1000 1000 0,10 100,00 Centro de retransmisión B -> Departamento de operaciones 800 1000 0,10 80,00 Cumplimiento de la demanda: Departamento de marketing: recibido 5000 / necesario 5000 Departamento de TI: recibido 4000 / necesario 4000 Departamento de Operaciones: recibido 3000 / necesario 3000
Simulaciones
Después de ejecutar 500 soluciones factibles con enrutamiento aleatorio de solicitudes de agentes a departamentos, podemos estimar que el resultado óptimo reduce los costos en un 33 % ($8425,98 − $5630,00 = $2795,98) en promedio.
───────────────────────── ───────────────────────── Red: enrutamiento de agentes ───────────────────────── ───────────────────────── Mínimo (óptimo): $5,630.00 Sim media: $8,425.98 Sim min: $5,750.00 Sim max: $11,150.00 Soluciones factibles: 500/500 ───────────────────────── ─────────────────────────
Mensaje para llevar a casa
En este artículo, cubrimos cuatro patrones de optimización comunes en la investigación de operaciones y su impacto comercial práctico, utilizando escenarios de planificación de agentes de IA:
Cobertura de conjunto: elija el conjunto más pequeño de agentes que aún cubra todas las tareas, habilidades o funciones comerciales requeridas, con el objetivo de minimizar costos sin dejar brechas en la capacidad. Tarea: Decidir qué agente debe manejar cada proyecto, con el objetivo de maximizar el valor de producción general. Mochila: seleccione el mejor paquete de agentes o funciones con un presupuesto fijo para maximizar la producción total de tokens. Red: Diseñe flujos de trabajo a través de una red de agentes para satisfacer la demanda del departamento y de los usuarios al menor costo bajo limitaciones de capacidad.
La planificación compleja de agentes se vuelve manejable cuando se enmarca como un modelo de optimización estándar con variables, restricciones y un objetivo. Los solucionadores modernos como Gurobi pueden encontrar rápidamente soluciones óptimas que reduzcan significativamente el gasto o aumenten el retorno de la inversión.
Más recursos como este
[insertar]https://www.youtube.com/watch?v=HMxFcB1AxFk[/embed]
[insertar]https://www.youtube.com/watch?v=Z5sK1iPsR-k[/embed]