Voy a desglosar exactamente cómo construir un modelo alfa multifactorial de grado hedge fund utilizando ingeniería de grafos.
Vamos directo al grano.
Guarda esto en favoritos
- Soy Roan, un desarrollador backend que trabaja en diseño de sistemas, ejecución estilo HFT y sistemas de trading cuantitativo. Mi trabajo se centra en cómo se comportan realmente los mercados de predicción bajo carga. Para cualquier sugerencia, colaboraciones reflexivas o asociaciones, los DM están abiertos.
En mi último artículo dije que guiaría personalmente las primeras 20 configuraciones de cualquiera que esté construyendo un sistema cuantitativo de IA, y lo decía en serio.
Pocos constructores ya están profundamente en el proceso conmigo. La oferta sigue abierta.
Si estás construyendo un sistema de ingeniería de grafos o 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. Guiaré 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 cada fondo de cobertura serio en Wall Street genera rendimientos. No negocian ideas únicas. Apilan factores.**Este es el mismo proceso que ejecuta AQR. El mismo proceso que ejecuta Two Sigma. El mismo proceso que ejecuta Bridgewater. Y es la primera vez que es ejecutable por un constructor solitario.
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 carteras. Analistas de riesgo. Ingenieros de ejecución. Necesitas al menos diez personas por familia de factores, y ningún cuant solitario puede construir ese equipo.
Por eso los cuants minoristas se apegan a estrategias únicas y los fondos de cobertura imprimen alfa.Hasta ahora.
https://x.com/RohOnChain/status/2074134246784921977
En mis últimos dos artículos expliqué la 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. Defines los nodos. 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 disparándose cada 24 horas en tu laptop.
Parte 1: Qué es realmente la ingeniería de grafos
Todo cuant que trabaja con IA está en algún punto de la misma progresión. Nombrar dónde estás hace obvio hacia dónde ir después.
Qué es realmente la ingeniería de grafos
Etapa 1: Prompts.
Escribes un prompt. Esperas. Lees la salida. 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 de ingeniería de bucles. Un agente, un trabajo, corriendo para siempre.
Etapa 3: Enjambres.
Expandes el bucle a muchos agentes con roles especializados. Uno genera señales. Uno las valida. Uno ejecuta. Esto es lo que enseñó el artículo de enjambre de agentes de IA. Múltiples agentes en paralelo, coordinados manualmente a través de código de pegamento en Python.
Etapa 4: Grafos.
Describes la estructura de coordinación una 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 de nuevo.
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 cualquiera te dice.
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 a través de ciclos. Un script se rompe en el momento en que quieres seis bucles en paralelo en diferentes modelos. Todo cuant 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ó.
Volvía 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 crash.
Para el segundo mes había pasado más tiempo depurando coordinación que haciendo investigación. Estaba a punto de archivar todo el proyecto.
Ese es el estado de fracaso que todo cuant multiagente alcanza. También es la razón por la que existen los grafos.
Un grafo no tiene esos modos de falla. El paralelismo es nativo. El estado es persistente. La falla 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 la falla 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 infraestructura que pueda ejecutarlo realmente.
Pasé semanas probando diferentes runtimes hasta que encontré 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. Recoge tus suscripciones de modelos existentes y distribuye el trabajo entre ellas.
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 por ti de forma continua.
Un prompt se ejecuta una vez y se detiene. Un Program continúa hasta que la tarea está terminada.
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 lo guarde y lo ejecute.
Si se rompe, conversas con Slate sobre la falla. Slate parcha 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 que se verifican
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 aleatorias
Slate no lanza un solo prompt a un modelo. Levanta un grafo.
Un nodo escribe la función. Otro escribe la prueba de verificación. Un tercero ejecuta ambos. Un cuarto califica si las salidas coinciden.
Si no coinciden, el grafo retrocede con el desajuste específico como retroalimentación. Continúa hasta que un modelo de calificación pequeño y separado confirma que el objetivo está cumplido.
Este es el patrón de creador-verificador en un runtime. El creador nunca califica 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 levanta aquí es diferente de /goal.
Es un abanico de investigación paralelo.
Slate despacha múltiples agentes trabajadores a la vez. Cada uno tiene un ángulo diferente de la pregunta.
Uno lee artículos recientes. Otro revisa arXiv q-fin. Otro extrae datos de la biblioteca de Kenneth French. Otro cruza referencias de citas.
Todos reportan a un orquestador central que sintetiza los hallazgos.La razón por la que /deepresearch importa 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 tiene 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 cuant.
Pasa 30 minutos ejecutando /goal y /deepresearch en preguntas que realmente te importan. Así es como ocurre 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ó momentum en 1997. Fama y French añadieron rentabilidad (RMW) e inversión (CMA) en 2015.
Los fondos de cobertura modernos ejecutan un stack 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 base ajustada por riesgo.
Factor 3: Valor (HML).
Alto valor contable respecto al mercado supera al bajo valor contable respecto al mercado en horizontes largos.
Factor 4: Momentum (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 de activos conservador supera a la expansión agresiva.
Factor 7: Baja Volatilidad.
Las acciones de baja volatilidad obtienen retornos ajustados por riesgo más altos de lo que predice la teoría.
Cada fondo ejecuta una versión de esto. Los constructores solitarios 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. Produce una 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 Momentum.
Calcula el momentum 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 de 10,000 iteraciones. Elimina cualquier factor con 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 Régimen.
Segmenta el historial de 20 años en tres regímenes utilizando un Modelo Oculto de Markov sobre volatilidad y retornos. Elimina cualquier cosa que solo funcione en un régimen.
Nodo 10: El Constructor de Cartera.
Combina los factores sobrevivientes en una cartera larga-corta utilizando ponderaciones de paridad de riesgo. Aplica neutralidad sectorial, beta y dólar.
Nodo 11: El Descomponedor de Riesgo.
Regresa la cartera 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 factorial son alfa nuevo genuino. Todo lo demás es estilo reempaquetado con pasos adicionales.
Once nodos. Cada uno tiene un trabajo. Pasan sus salidas hacia abajo en el grafo.
Todo el modelo se ejecuta en un solo Program de Slate que se dispara cada 24 horas.
Parte 4: Cómo construirlo paso a paso
Aquí está la construcción exacta. Sigue en tu terminal.
Paso 1: Instalar Slate
Abre tu terminal y ejecuta:
1npm i -g @randomlabs/slate
Slate es un paquete npm global. 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, pruebas históricas de factores, instantáneas de cartera viven aquí.
1mkdir ~/projects/multifactor-alpha2cd ~/projects/multifactor-alpha
No ejecutes otros proyectos de Slate desde la misma carpeta. El espacio de nombres de 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 todos los proveedores conectados. Random Labs aloja alrededor de 90 modelos.
Quieres 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, auditor de régimen y descomponedor de riesgo. Claude Opus funciona.
Paso 6: Calentar con /goal y /deepresearch
Antes de redactar tu propio Program, pasa 30 minutos con 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 de 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 despliega. Observa cómo el modelo calificador 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 difieren empíricamente de 2015 a 2026
Observa el abanico 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 Program 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:
1rédactame un Program que ejecute siete agentes de investigación multifactorial en paralelo: beta de mercado, tamaño, valor, momentum, rentabilidad, inversión y baja volatilidad. Después de que todos los siete completen, ejecuta un validador, un auditor de régimen, un constructor de cartera y un descomponedor de riesgo en secuencia. Usa Claude Sonnet para los siete agentes de factor y Claude Opus para el validador, auditor de régimen y descomponedor de riesgo. Ejecuta todo el pipeline cada 24 horas. Usa el sistema de archivos como memoria. Establece un presupuesto de $30 por ejecución. Aplica un estadístico t ajustado por Newey-West por encima de 2.5, bootstrap de 10,000 iteraciones, y rechaza cualquier factor con degradación del Sharpe dentro de muestra versus fuera de muestra superior 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 régimen. 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 viendo la estructura de coordinación.
Siete nodos de factor 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 sueño. Un bucle de regreso al inicio.
Haz preguntas a Slate sobre el diagrama antes de ejecutar algo:
- ¿Por qué el validador se ejecuta en Opus?
- ¿Qué sucede si el agente de momentum agota el tiempo?
- ¿Qué estado se persiste entre ciclos?
- ¿Qué desencadena que el auditor de régimen 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 guarde el Program en un archivo. Luego ejecuta:
1slate run multifactor-alpha.js
En el momento en que presionas enter, Slate levanta el grafo. Los siete agentes de factor se disparan 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 rompe
Los Programs 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 momentum ocasionalmente devolvía cero señales sobrevivientes en regímenes hostiles al momentum. Se lo dije a Slate. Slate añadió un respaldo que amplía la ventana de retrospectiva de momentum durante esos regímenes.
El constructor de cartera 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 la cartera.
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 Program de una sola vez. No un borrador. El JavaScript completo. Once nodos conectados. Construcción de factores en paralelo. Validación secuencial. Memoria compartida del 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 cartera. Mi prompt de borrador especificaba Opus para el validador, auditor de régimen y descomponedor de riesgo, pero no nombré un modelo para el constructor de cartera. Slate lo predeterminó a Opus porque la etapa es un trabajo analítico pesado, pero lo marcó como intercambiable si quería Sonnet.
Decisión 2: Versiones de modelo. Slate usó las versiones estables actuales de Sonnet y Opus (4.6 y 4.5) y ofreció actualizar a versiones más nuevas si 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 consultivo, no un interruptor de apagado duro. 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 auto-reportado que se suma y se marca. Si quería una interrupción forzada a mitad de la ejecución, Slate ofreció diseñarlo explícitamente.
Esa tercera observación es por qué confío en esta herramienta. La mayoría de los frameworks de agentes pretenderían silenciosamente que el presupuesto se aplicaba. Slate me dijo exactamente qué capa de aplicación podía proporcionar realmente.
Confirmé los tres valores predeterminados, renombré el Program a multifactor-research-pipeline y le dije a Slate que lo guardara.
Luego presioné ejecutar.
Los siete agentes de factor se dispararon 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 factor en paralelo en Sonnet, luego la secuencia validador → régimen → cartera → riesgo en Opus, con valores predeterminados (./research-memory, presupuesto de $30, las tres compuertas, bucle perpetuo de 24 horas)."
Esa sola 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 al inicio. 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 Program 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 a.m. de tu hora local, el grafo se despierta.
Los siete agentes de factor se disparan en paralelo. Cada uno extrae las últimas 24 horas de datos de precio y fundamentales. Actualiza su serie temporal de factor. Entrega al validador.
El validador ejecuta pruebas t de Newey-West. Remuestrea 10,000 muestras. Elimina cualquier cosa que haya fallado fuera de muestra.
Este paso solo rechaza aproximadamente el 80 por ciento de lo que parece prometedor en un primer backtest.
El auditor de régimen 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 cartera toma los factores sobrevivientes. Construye la cartera larga-corta con las restricciones de neutralidad aplicadas.
El descomponedor de riesgo toma la cartera. La regresa contra el conjunto amplio de factores de estilo y macro.
Si el estadístico t del alfa residual está por encima de 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 negociar, o tienes evidencia documentada de que hoy fue ruido.
Ambos resultados son útiles. Ninguno requirió que estuvieras en el teclado.
Esto es lo que parece un modelo alfa multifactorial auto-ejecutable en 2026.
El plano
Si no recuerdas nada más, recuerda estos siete movimientos 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 grafo antes de escribir una línea de código.
4. Usa modelos diferentes para nodos diferentes. Sonnet para la construcción de factores. Opus para la validación y descomposición. Maker nunca valida a Maker.
5. Aplica reglas estrictas. Estadístico t de Newey West por encima de 2.5. Bootstrap de 10,000 iteraciones. Robustez de régimen en tres estados HMM. Estadístico t de alfa residual por encima de 2.5.
6. Calienta con /goal y /deepresearch. La intuición sobre ingeniería de grafos se adquiere observando grafos, no leyendo sobre ellos.
7. Deja que se acumule. El primer mes es encontrar errores. El segundo mes es refinar factores. Para el tercer mes, tu grafo producirá señales con las que realmente puedes operar.
Ahora ve a construirlo
Instala Slate esta noche. Ejecútalo. Lanza /goal con una pregunta cuantitativa real. Ejecuta /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 grafo multifactorial auto-ejecutable.
Para esta misma hora el próximo mes, tendrás tu primera señal transaccionable que sobreviva los once nodos.
Ese es el trato. Un fin de semana de configuración para un sistema de investigación que se acumula y nunca duerme.
Ahora ve a construirlo.
Si te atascas en alguna parte del proceso, envíame un mensaje directo aquí.
Puedes encontrar Slate en http://randomlabs.ai/rr.
Sigue a @wearerandomlabs si quieres ver cada funcionalidad que lanzan. /goal y /deepresearch son los primeros dos Programas. No serán los últimos.
