Voy a desglosar exactamente cómo construir un modelo alfa multifactorial de grado institucional utilizando ingeniería de grafos.
Vamos directo al grano.
Guarda esto
- Soy Roan, desarrollador backend especializado en diseño de sistemas, ejecución al estilo HFT y sistemas de trading cuantitativo. Mi trabajo se centra en cómo se comportan realmente los mercados de predicción bajo carga. Si tienes sugerencias, colaboraciones interesantes o alianzas, los DM están abiertos.
En mi artículo anterior dije que personalmente guiaría los primeros 20 montajes de cualquiera que estuviera construyendo un sistema cuantitativo con IA, y lo dije en serio.
Algunos constructores ya están avanzando en el proceso conmigo. La oferta sigue en pie.
Si estás construyendo un sistema de ingeniería de grafos, a punto de empezar, o incluso solo pensando en ello, responde debajo de este artículo o envíame un DM con tu configuración actual. Revisaré personalmente tu arquitectura y te mostraré la brecha entre lo que tienes y un enjambre que caza alfa por sí solo.
Si no respondo, no estabas entre los primeros 20. Muévete rápido.La inversión multifactorial es cómo todos los fondos de cobertura serios en Wall Street generan rendimientos. No operan con ideas individuales. Apilan factores.**Es el mismo proceso que ejecuta AQR. El mismo que ejecuta Two Sigma. El mismo que ejecuta Bridgewater. Y es la primera vez que un constructor individual puede ejecutarlo.
El problema siempre ha sido que construir esto requería un equipo de investigación. Ingenieros de factores. Estadísticos. Especialistas en construcción de portafolios. Analistas de riesgo. Ingenieros de ejecución. Necesitas al menos diez personas por familia de factores, y ningún cuantitativo individual puede formar ese equipo.
Por eso los cuantitativos minoristas se quedan con estrategias individuales y los fondos de cobertura imprimen alfa.Hasta ahora.
https://x.com/RohOnChain/status/2074134246784921977
En mis dos últimos artículos hablé sobre ingeniería de bucles y cómo construir un enjambre de agentes de IA que caza alfa 24/7.
Una vez que tienes bucles y enjambres, la capa que los mantiene unidos como un sistema funcional es un grafo.
La ingeniería de grafos es la práctica de diseñar esa capa. Tú defines los nodos. Tú defines las aristas. El grafo funciona solo.
Al final de este artículo no solo entenderás la ingeniería de grafos.
Tendrás un modelo alfa multifactorial auto-ejecutable que se activa cada 24 horas en tu laptop.
Parte 1: Qué es realmente la Ingeniería de Grafos
Cada cuantitativo que trabaja con IA está en algún punto de la misma progresión. Saber dónde estás hace que sea obvio hacia dónde ir después.
Qué es realmente la Ingeniería de Grafos
Etapa 1: Prompts.
Escribes un prompt. Esperas. Lees el resultado. Escribes el siguiente. Tú eres el bucle. Nada sobrevive cuando cierras la laptop.
Etapa 2: Bucles.
Escribes un script que envuelve el prompt y se ejecuta en un horario. El bucle mantiene el estado. Sobrevive después de que cierras la laptop. Esto es lo que enseñó mi artículo sobre ingeniería de bucles. Un agente, una tarea, ejecutándose para siempre.
Etapa 3: Enjambres.
Expandes el bucle en muchos agentes con roles especializados. Uno genera señales. Uno las valida. Uno ejecuta. Esto es lo que enseñó el artículo sobre enjambres de agentes de IA. Múltiples agentes en paralelo, coordinados manualmente mediante código de pegamento en Python.
Etapa 4: Grafos.
Describe la estructura de coordinación una sola vez. Los nodos son agentes. Las aristas son transferencias de datos. El grafo sabe cuándo paralelizar, cuándo esperar, cuándo reintentar, cuándo escalar. No tocas el código de pegamento nunca más.
La ingeniería de grafos es la práctica de diseñar esa estructura de coordinación.
Un grafo no es un script. Esa distinción importa más de lo que te dicen.
Un script se rompe en el momento en que un agente necesita esperar a otro. Un script se rompe en el momento en que el estado debe persistir entre ciclos. Un script se rompe en el momento en que quieres seis bucles en paralelo en diferentes modelos. Cada cuantitativo minorista que ha intentado construir un sistema multiagente se ha topado con estas tres paredes.
La pared del fracaso me rompió. Cuando mi agente de rentabilidad se bloqueó porque tenía que analizar 500 balances y alcanzó los límites de tasa, todo el pipeline murió.
Regresaba a la mañana siguiente a un proceso detenido, sin señal y sin idea de dónde se originó la falla. Depurar significaba leer un stack trace y adivinar qué agente estaba antes del bloqueo.
Para el segundo mes, había pasado más tiempo depurando la coordinación que haciendo investigación. Estaba a punto de archivar todo el proyecto.
Ese es el estado de fracaso que todo cuantitativo multiagente encuentra. También es la razón por la que existen los grafos.
Un grafo no tiene esos modos de fallo. El paralelismo es nativo. El estado es persistente. El fallo se limita al nodo, no al pipeline. Cuando un nodo se rompe, el resto del grafo sigue funcionando, y tú reparas el nodo roto describiendo el fallo en inglés sencillo.
Esa es la promesa de la ingeniería de grafos. Ahora la pregunta es qué ejecuta el grafo.
Parte 2: La Herramienta Que Ejecuta el Grafo
Los grafos son diagramas arquitectónicos. No se ejecutan solos. Necesitan un runtime.
El runtime es lo que la mayoría de las personas que construyen sistemas multiagente hacen mal.
Asumen que la parte difícil es diseñar el grafo. No lo es. La parte difícil es encontrar una infraestructura que realmente pueda ejecutarlo.
Pasé semanas probando diferentes runtimes antes de encontrar uno que pudiera ejecutar un grafo multifactorial de principio a fin.
El que uso se llama Slate. Creado por @wearerandomlabs. Se ejecuta en tu terminal. Toma tus suscripciones de modelos existentes y distribuye el trabajo entre ellos.
Lo que importa para este artículo es una capacidad que lanzaron recientemente llamada Programs. Un Program es un grafo escrito en JavaScript que Slate ejecuta continuamente por ti.
Un prompt se ejecuta una vez y se detiene. Un Program continúa hasta que la tarea está hecha.
No escribes el Program solo. Le dices a Slate lo que quieres en inglés sencillo. Slate redacta el grafo.
Slate luego te presenta un diagrama. Haces preguntas sobre el diagrama. Cambias nodos. Ajustas modelos. Solo cuando estás satisfecho le dices a Slate que guarde y ejecute.
Si se rompe, conversas con Slate sobre el fallo. Slate repara el grafo.
Puedes encontrar Slate en http://randomlabs.ai/rr. Está disponible hoy.
La mejor manera de sentir la ingeniería de grafos antes de construir uno es ejecutar los dos Programs de ejemplo que vienen con Slate.
Se llaman
/goal
y
/deepresearch
.
/goal - Grafos Que Se Ejecutan Hasta Completarse Verificablemente
Escribe esto dentro de Slate:
1/goal implementar una función de estadístico t ajustado por Newey-West en Python y verificar que coincida con la implementación de statsmodels en diez series de retornos aleatorios
Slate no lanza un solo prompt a un modelo. Activa un grafo.
**Un nodo escribe la función. Otro escribe la prueba de verificación. Un tercero ejecuta ambos. Un cuarto evalúa si los resultados coinciden.**
Si no coinciden, el grafo vuelve al ciclo con la discrepancia específica como retroalimentación. Continúa hasta que un modelo evaluador pequeño y separado confirma que el objetivo está completo.
Este es el patrón de creador-verificador en un runtime. El creador nunca evalúa su propio trabajo.
/deepresearch - Grafos Que Paralelizan la Investigación
Prueba esto dentro de Slate:
1/deepresearch ¿qué dice la investigación académica más reciente sobre el rendimiento fuera de muestra del modelo de cinco factores de Fama-French en mercados emergentes de 2015 a 2026?
El grafo que se activa aquí es diferente de /goal.
Es una expansión de investigación en paralelo.
Slate despliega múltiples agentes trabajadores a la vez. Cada uno maneja un ángulo diferente de la pregunta.
Uno lee artículos recientes. Otro revisa arXiv q-fin. Otro extrae datos de la biblioteca Kenneth French. Otro cruza referencias de citas.
Todos reportan a un orquestador central que sintetiza los hallazgos.La razón por la que /deepresearch es importante para esta construcción es que demuestra el patrón exacto que necesitas para la construcción de factores.
Siete agentes de factores. Cada uno maneja un factor diferente. Todos ejecutándose en paralelo. Todos reportando a un orquestador central.
Ese es el grafo multifactorial, menos las tareas específicas de cuantitativos.
Dedica 30 minutos a ejecutar /goal y /deepresearch en preguntas que realmente te importen. Así es como se desarrolla la intuición de la ingeniería de grafos.
Parte 3: El Grafo Alfa Multifactorial
La inversión multifactorial descompone los retornos de las acciones en impulsores sistemáticos más un residual. La versión fundamental es el modelo de tres factores de Fama-French, publicado en 1993:
R_i es el retorno de la acción i. R_f es la tasa libre de riesgo. R_m es el retorno del mercado. SMB es la prima de tamaño. HML es la prima de valor.
El alfa α es lo que el modelo no puede explicar. Ese residual es lo que estás cazando.
Carhart añadió el momento en 1997. Fama y French añadieron rentabilidad (RMW) e inversión (CMA) en 2015.
Los fondos de cobertura modernos ejecutan una pila de siete factores. AQR, Two Sigma, Millennium, Bridgewater todos ejecutan variantes. Aquí están los siete factores que importan en 2026.
Factor 1: Beta de Mercado.*
Regresión móvil de 60 meses del exceso de retorno de la acción contra el exceso de retorno del mercado.
Factor 2: Tamaño (SMB).*
Las pequeñas capitalizaciones superan a las grandes capitalizaciones en una base ajustada al riesgo.
Factor 3: Valor (HML).*
El alto valor contable respecto al mercado supera al bajo valor contable respecto al mercado en horizontes largos.
Factor 4: Momento (MOM).*
Los ganadores de los últimos 12 meses siguen ganando durante 3 a 12 meses.
Factor 5: Rentabilidad (RMW).*
Los operadores robustos superan a los operadores débiles.
Factor 6: Inversión (CMA).*
El crecimiento conservador de activos supera a la expansión agresiva.
Factor 7: Baja Volatilidad.*
Las acciones de baja volatilidad obtienen retornos ajustados al riesgo más altos de lo que predice la teoría.
Cada fondo ejecuta una versión de esto. Los constructores individuales no pueden porque necesita un equipo de investigación.
La ingeniería de grafos resuelve eso. Cada factor se convierte en un nodo.
Aquí está el grafo completo. Once nodos en total.
Nodos de Construcción de Factores (se ejecutan en paralelo)
Nodo 1: Agente de Beta de Mercado.
Ejecuta la regresión móvil de 60 meses. Genera un beta para cada acción.
Nodo 2: Agente de Tamaño.
Ordena por capitalización de mercado. Calcula el diferencial pequeño-grande.
Nodo 3: Agente de Valor.
Ordena por valor contable respecto al mercado. Calcula el diferencial alto-bajo.
Nodo 4: Agente de Momento.
Calcula el momento de 12 menos 1 mes. Construye MOM a partir del diferencial de deciles.
Nodo 5: Agente de Rentabilidad.
Calcula la rentabilidad bruta. Construye RMW.
Nodo 6: Agente de Inversión.
Calcula el crecimiento anual de activos. Construye CMA.
Nodo 7: Agente de Baja Volatilidad.
Calcula la volatilidad realizada de los últimos 60 días. Construye baja volatilidad a partir del diferencial de deciles.
Nodos de Coordinación (se ejecutan en secuencia)
Nodo 8: El Validador.
Ejecuta estadísticos t ajustados por Newey-West en cada factor. Remuestrea bootstrap con 10,000 iteraciones. Elimina cualquier factor con una degradación dentro de muestra versus fuera de muestra superior al 30 por ciento.
Se ejecuta en un modelo de razonamiento más fuerte. El creador nunca valida su propio trabajo.
Nodo 9: El Auditor de Regímenes.
Segmenta el historial de 20 años en tres regímenes usando un Modelo Oculto de Márkov sobre volatilidad y retornos. Elimina cualquier cosa que solo funcione en un régimen.
Nodo 10: El Constructor de Portafolios.
Combina los factores supervivientes en un portafolio largo-corto usando ponderaciones de paridad de riesgo. Aplica neutralidad sectorial, de beta y de dólar.
Nodo 11: El Descomponedor de Riesgo.
Regresa el portafolio contra los siete factores más factores de estilo y macro. Reporta el alfa residual y el estadístico t.
Solo las señales donde el alfa residual sobrevive a la descomposición de factores son alfa genuinamente nuevo. Todo lo demás es estilo reempaquetado con pasos adicionales.
Once nodos. Cada uno tiene una tarea. Pasan sus resultados hacia abajo en el grafo.
Todo el modelo se ejecuta en un solo Programa de Slate que se activa cada 24 horas.
Parte 4: Cómo Construirlo Paso a Paso
Aquí está la construcción exacta. Sigue el proceso en tu terminal.
Paso 1: Instalar Slate
Abre tu terminal y ejecuta:
1npm i -g @randomlabs/slate
Slate es un paquete global de npm. La instalación toma unos 30 segundos.
Verifica con:
1slate --version
Paso 2: Crear tu Directorio de Proyecto
La investigación multifactorial necesita su propio espacio de trabajo. Los archivos de estado, las pruebas históricas de factores y las instantáneas del portafolio viven aquí.
1mkdir ~/projects/multifactor-alpha2cd ~/projects/multifactor-alpha
No ejecutes otros proyectos de Slate desde la misma carpeta. El espacio de nombres del estado es por espacio de trabajo.
Paso 3: Iniciar Slate
Escribe:
1slate
Paso 4: Conectar tus Proveedores
Dentro de Slate, escribe:
1/providers
Esto abre la pantalla de configuración de proveedores. Random Labs se autentica por defecto. También puedes conectar OpenAI Codex y GitHub Copilot directamente.
Navega a Codex con las teclas de flecha y presiona enter para autenticarte. Tu suscripción existente funciona.
Paso 5: Conectar tus Modelos
Dentro de Slate, escribe:
1/models
Ves todos los modelos disponibles en cada proveedor conectado. Random Labs aloja alrededor de 90 modelos.
Necesitas dos niveles de modelos.
Un nivel rápido para los siete agentes de construcción de factores. Claude Sonnet funciona.
Un nivel de razonamiento más fuerte para el validador, el auditor de regímenes y el descomponedor de riesgo. Claude Opus funciona.
Paso 6: Calentar con /goal y /deepresearch
Antes de redactar tu propio Program, dedica 30 minutos a los dos Programs de ejemplo incluidos.
Así es como la ingeniería de grafos deja de ser un concepto y comienza a ser intuición.
Prueba este comando /goal dentro de Slate:
1/goal escribir una función en Python que calcule coeficientes de regresión transversal de Fama-MacBeth y verificar que coincida con el paquete empiricalfin en 20 años de datos de retornos mensuales
Observa cómo el grafo se expande. Observa cómo el modelo evaluador verifica el trabajo del modelo escritor. Observa qué sucede cuando el primer intento falla.
Luego prueba este comando /deepresearch:
1/deepresearch ¿qué dice la literatura académica sobre el factor de rentabilidad RMW versus el factor de calidad definido por MSCI y cómo se diferencian empíricamente de 2015 a 2026?
Observa la expansión de trabajadores en paralelo. Observa cómo el orquestador sintetiza.
Estas dos ejecuciones te dan el modelo mental que necesitas antes de escribir tu propio Program.
Paso 7: Redactar el Programa Multifactorial
Este es el paso más importante. Describes el grafo en inglés sencillo y Slate lo redacta contigo.
Escribe este prompt exacto en Slate:
1redáctame un programa que ejecute siete agentes de investigación multifactorial en paralelo:2beta de mercado, tamaño, valor, momento, rentabilidad, inversión y baja volatilidad.3Después de que los siete se completen, ejecuta un validador, un auditor de regímenes, un constructor4de portafolios y un descomponedor de riesgo en secuencia. Usa Claude Sonnet para los siete5agentes de factores y Claude Opus para el validador, el auditor de regímenes y el descomponedor de riesgo.6Ejecuta todo el pipeline cada 24 horas. Usa el sistema de archivos como memoria. Establece un presupuesto7de $30 por ejecución. Aplica un estadístico t de Newey-West superior a 2.5, bootstrap de 10,000 iteraciones8y rechaza cualquier factor con una degradación del Sharpe dentro de muestra versus fuera de muestra9superior al 30 por ciento.
Slate no solo comienza a escribir código. Lee cuidadosamente y hace preguntas aclaratorias.
Qué fuente de datos. Qué ventana de backtest. Qué universo. Qué clasificador de regímenes. Si usar valores predeterminados anulables.
Respondes en inglés sencillo. Slate escribe el JavaScript.
Paso 8: Revisar el Diagrama del Grafo
Una vez que Slate ha redactado el Program, renderiza un diagrama del grafo.
No estás leyendo código para entender qué se ejecutará. Estás mirando la estructura de coordinación.
Siete nodos de factores ejecutándose en paralelo desde el orquestador. Un punto de sincronización. Cuatro nodos de coordinación en secuencia. Un paso de persistencia. Un nodo de espera. Un bucle de vuelta al inicio.
Haz preguntas a Slate sobre el diagrama antes de ejecutar nada:
- ¿Por qué el validador se ejecuta en Opus?
- ¿Qué sucede si el agente de momento se agota?
- ¿Qué estado se persiste entre ciclos?
- ¿Qué desencadena que el auditor de regímenes rechace un factor?
Si alguna respuesta te sorprende, pídele a Slate que cambie el grafo.
Paso 9: Guardar y Ejecutar
Una vez que el diagrama coincida con lo que quieres, dile a Slate que confirme el Program en un archivo. Luego ejecuta:
1slate run multifactor-alpha.js
En el momento en que presionas enter, Slate activa el grafo. Los siete agentes de factores se ejecutan en paralelo.
La ingeniería de características se ejecuta en paralelo. La validación se ejecuta en el modelo más fuerte.
La primera ejecución toma de 15 a 25 minutos. Las ejecuciones diarias posteriores son más rápidas porque el archivo de estado ya contiene el historial.
Paso 10: Establecer un Presupuesto
Dentro de Slate, escribe:
1/budget $30/run
Esto limita el gasto total por ejecución. Si una ejecución se acerca al límite, Slate escala antes de continuar.
Paso 11: Depurar Cuando se Rompa
Los Programas reales se rompen. El mío se rompió tres veces en las primeras dos semanas.
El agente de valor se bloqueó porque no podía interpretar balances no estadounidenses. Se lo dije a Slate. Slate parcheó el agente de valor para incluir un paso de normalización de moneda.
El agente de momento ocasionalmente devolvía cero señales supervivientes en regímenes hostiles al momento. Se lo dije a Slate. Slate añadió un respaldo que amplía la ventana de observación del momento durante esos regímenes.
El constructor de portafolios a veces violaba la neutralidad sectorial. Se lo dije a Slate. Slate añadió un paso de proyección para aplicar la neutralidad antes de escribir el portafolio.
No persigues un stack trace. Describes el problema a Slate. Slate parchea el nodo.
Parte 5: Lo Que Realmente Sucedió Cuando lo Ejecuté
Aquí está la parte que no esperaba.
Le describí el grafo a Slate en un párrafo. Slate primero verificó los identificadores de modelo disponibles, activó la habilidad de modelos y eligió claude-sonnet-4.6 para los agentes rápidos y claude-opus-4.5 para las etapas de coordinación.
Luego Slate redactó todo el Programa en una sola pasada. No un borrador. El JavaScript completo. Once nodos conectados. Construcción de factores en paralelo. Validación secuencial. Memoria compartida en el sistema de archivos con directorios de ejecución con marca de tiempo. Asignaciones de presupuesto. Todo.
Slate no solo escribió código y desapareció. Volvió con tres decisiones específicas que quería que confirmara antes de ejecutarlo.
Decisión 1: Modelo del constructor de portafolios. Mi prompt inicial especificaba Opus para el validador, el auditor de regímenes y el descomponedor de riesgo, pero no mencioné un modelo para el constructor de portafolios. Slate lo predeterminó a Opus porque la etapa es un trabajo analítico pesado, pero lo marcó como modificable si prefería Sonnet.
Decisión 2: Versiones de modelos. Slate usó las versiones estables actuales de Sonnet y Opus (4.6 y 4.5) y ofreció actualizar a versiones más nuevas si lo prefería.
Decisión 3: Aplicación del presupuesto. Esta me sorprendió. Slate me dijo explícitamente que el límite de $30 por ejecución era indicativo, no un interruptor de apagado forzoso. No hay una primitiva de medición de costos en tiempo real, por lo que el presupuesto se aplica como un límite declarado más el gasto autoinformado que se suma y se señala. Si quería una interrupción forzosa a mitad de la ejecución, Slate ofreció diseñarlo explícitamente.
Esa tercera advertencia es por qué confío en esta herramienta. La mayoría de los frameworks de agentes fingirían silenciosamente que el presupuesto se aplicaba. Slate me dijo exactamente qué nivel de aplicación podía proporcionar realmente.
Confirmé los tres valores predeterminados, renombré el Programa a multifactor-research-pipeline y le dije a Slate que lo confirmara.
Luego presioné ejecutar.
Los siete agentes de factores se activaron de inmediato. Cada uno apareció en la terminal con su propio ID de subagente y temporizador de estado.
Slate confirmó la ejecución en inglés sencillo:
"Se está ejecutando en segundo plano como multifactor-pipeline, comenzando con los siete agentes de factores en paralelo en Sonnet, luego la secuencia validador → régimen → portafolio → riesgo en Opus, con valores predeterminados (./research-memory, presupuesto de $30, las tres compuertas, bucle perpetuo de 24 horas)."
Esa única línea captura por qué los grafos superan a los scripts.
No escribí código de coordinación. No perseguí un stack trace. No pegué APIs. Describí el grafo en inglés sencillo, respondí tres preguntas de diseño y Slate lo construyó.
Todo es anulable en el lanzamiento. Intervalo, presupuesto, umbrales de compuerta, modelos, ubicación de memoria y un límite de maxRuns si no quieres que el grafo se ejecute para siempre.
Aquí está el Programa completo que Slate escribió para mí. Estúdialo, pero no lo copies textualmente. El tuyo se verá ligeramente diferente dependiendo de las respuestas que diste a las preguntas aclaratorias de Slate.
Parte 6: Lo Que Sucede Cada 24 Horas
A las 3 de la mañana, el grafo se despierta.
Los siete agentes de factores se ejecutan en paralelo. Cada uno extrae las últimas 24 horas de datos de precios y fundamentales. Actualiza su serie temporal de factores. Entrega al validador.
El validador ejecuta pruebas t de Newey-West. Bootstrap con 10,000 muestras. Elimina cualquier cosa que falle fuera de muestra.
Este paso por sí solo rechaza aproximadamente el 80 por ciento de lo que parece prometedor en una primera prueba retrospectiva.
El auditor de regímenes toma lo que sobrevivió. Segmenta el historial usando el HMM. Recalcula el Sharpe por régimen.
Un factor que solo funciona en un régimen no es alfa. Es beta a ese régimen, disfrazado de alfa.
El constructor de portafolios toma los factores supervivientes. Construye el portafolio largo-corto con las restricciones de neutralidad aplicadas.
El descomponedor de riesgo toma el portafolio. Lo regresa contra el conjunto amplio de factores de estilo y macro.
Si el estadístico t del alfa residual es superior a 2.5, la señal sobrevive. Si no, el día se registra como sin señal y el grafo duerme hasta mañana.
Cada mañana te despiertas con un mensaje de Slack. O tienes una señal que puedes operar. O tienes evidencia documentada de que hoy fue ruido.
Ambos resultados son útiles. Ninguno requirió que estuvieras frente al teclado.
Así es como se ve un modelo alfa multifactorial auto-ejecutable en 2026.
El Plan
Si no recuerdas nada más, recuerda estos siete pasos en orden.
1. Entiende la progresión. Los prompts se convirtieron en bucles. Los bucles se convirtieron en enjambres. Los enjambres se convirtieron en grafos.
2. Conoce tus factores. Mercado, tamaño, valor, momentum, rentabilidad, inversión, baja volatilidad. Siete factores. Cada uno se convierte en un nodo.
3. Diseña once nodos. Siete agentes de factores en paralelo. Cuatro agentes de coordinación en secuencia. Dibuja el gráfico antes de escribir una línea de código.
4. Usa diferentes modelos para diferentes nodos. Sonnet para la construcción de factores. Opus para validación y descomposición. El creador nunca valida al creador.
5. Aplica reglas estrictas. t stat de Newey West por encima de 2.5. Bootstrap de 10,000 iteraciones. Robustez de régimen a través de tres estados HMM. t stat de alfa residual por encima de 2.5.
6. Calienta con /goal y /deepresearch. La intuición de ingeniería de gráficos viene de observar gráficos, no de leer sobre ellos.
7. Déjalo que se acumule. El mes uno es encontrar errores. El mes dos es refinar factores. Para el mes tres, tu gráfico produce señales que realmente puedes operar.
Ahora ve y constrúyelo
Instala Slate esta noche. Ejecútalo. Corre /goal en una pregunta cuantitativa real. Corre /deepresearch sobre un factor que te intrigue.
Luego redacta tu propio Programa con el prompt exacto del Paso 6. Revisa el diagrama. Ejecútalo. Establece un presupuesto de $30.
Para esta misma hora la próxima semana, tendrás tu primer gráfico multifactorial auto-ejecutable.
Para esta misma hora el próximo mes, tendrás tu primera señal negociable que sobreviva los once nodos.
Ese es el trato. Un fin de semana de configuración para un sistema de investigación compuesto que nunca duerme.
Ahora ve y constrúyelo.
Si te atascas en alguna parte de la construcción, envíame un DM aquí.
Puedes encontrar Slate en http://randomlabs.ai/rr.
Sigue a @wearerandomlabs si quieres ver cada capacidad que lancen. /goal y /deepresearch son los primeros dos Programas. No serán los últimos.
