# Chainlink CRE en Español

> La capa de orquestación (Orchestation Layer) todo en uno

Canonical: https://www.gilbertsahumada.com/blog/chainlink-cre/
Last updated: 2025-11-29

Chainlink · Runtime

Si Chainlink ya era el estándar de referencia en oráculos, CRE redefine la plataforma entera y la convierte en un entorno de ejecución modular, seguro y totalmente programable. Con CRE, cualquier desarrollador puede construir workflows que combinan capacidades on-chain y off-chain: leer y escribir en blockchain, ejecutar lógica personalizada, llamar APIs, coordinar múltiples DONs y construir aplicaciones híbridas que antes requerían infraestructura compleja.

En este artículo explico qué es CRE, por qué es tan importante para el futuro de web3, su funcionamiento y cómo puedes crear tu primer workflow.

### ¿Qué es Chainlink CRE?

Chainlkink Runtime Environment (CRE) es la nueva capa de orquestación de Chainlink: un entorno descentralizado que ejecuta workflows programables construidos a partir de capacidades modulares, cada una respaldada por su propia Descentralized Oracle Network (DON) especializada.

En pocas palabras:

> <em>CRE es un "runtime descentralizado”que ejecuta lógica off-chain y on-chain con garantías criptográficas de consenso.</em>

A diferencia de los servicios hasta ahora lanzados por Chainlink (Automation, Functions, Data Feeds), CRE permite componer capacidades básicas como piezas de microservicios:

* Leer desde una blockchain

* Escribir transacciones

* Llamas APIs externas (autenticadas o públicas)

* Ejecutar cómputo off-chain

* Validar políticas de compliance

* Conectarse con blockchains públicas o privadas

* Coordinar múltiples DONs con consenso BFT

* Asegurar resultados verificables de extremo a extremo

Todo dentro de un solo workflow, escribiendo código en Go y/o TypeScript, compilando automáticamente a WebAssembly (WASM).

### La nueva arquitectura: Capabilities + CRE

Chainlink reescribió la plataforma siguiendo un enfoque inspirado en microservicios.

Ahora todas las capacidades de los servicios que antes eran propios de cada uno de ellos como: <strong>read chain, write chain, fetch API, compute</strong>, policy, etc. Ahora todas estas capabilities se pueden implementar libremente a través de CRE en un único o múltiples workflows, según las necesidades.

Un workflow DON orquesta toda la ejecución.

* monitorea triggers

* coordina ejecución

* comunica DONs entre sí

* garantiza consenso

Esto hace que la plataforma:

* sea reutilizable

* escale má rápido

* cargue menos complejidad para nosotros los devs

* permite integraciones antes impensadas

### ¿Qué podemos hacer hoy con CRE?

#### Build and Simulate (disponible ahora)

Cualquier desarrollador puede:

* Crear una cuenta en [cre.chain.link](https://cre.chain.link/login)

* Instalar el [CRE CLI ](https://docs.chain.link/cre/getting-started/cli-installation)

* Construir workflows en Go o TypeScript

* Simular workflows localmente

La simulación

* Compila tu workflow a WASM

* lo ejecuta en tu máquina

* pero realiza llamas reales a APIs y blockchains públicas

Es decir:

Puedes probar wofklows reales sin necesidad de desplegarlos en un DON.

#### Deploy on Mainnet (Early Acces)

La etapa actual permite:

* desplegar workflows en un DON real

* activar, pausar, actualizar o borrar workflows

* ver logs y métricas en el UI de CRE

* monitorear cada ejecución

* recibir soporte según tu caso de uso

Esta etapa está sujeta a cambios y mejoras, pero ya funciona en producción.

### ¿Cómo funcionan los workflows en CRE y cómo se gatillan?

El concepto clave aquí es <strong>workflow</strong> y ahora los entenderemos más a fondo. En chainlink CRE, un <strong>workflow </strong>es un programa que tú escribes en Go o TypeScript y que luego se compila a WebAssembly (WASM). Ese workflow se ejecuta de manera descentralizada por una DON (Decentralized Oracle Network), que se encarga de:

* escuchar los eventos que lo gatillan (ya hablaremos más de esto)

* coordinar la ejecución de tu lógica

* invocar las capacidades necesarias

* agregar los resultados mediante consenso

En otras palabras:

> Un workflow es la unidad fundamental de ejecución en CRE: es tu backend serverless, pero descentralizado y con consenso.

#### La arquitectura trigger → callback

Cada workflow sigue un modelo que es muy simple pero poderoso"

Trigger → Callback → Resultado

* Trigger: define cuándo se debe ejecutar tu lógica

* Callback: define qué debe suceder cuando se gatilla

* cre.handler(): conecta un trigger con su callback

Pondré algunos ejemplos de código simplificados pero cuando veas el video publicado en [mi canal de youtube](https://www.youtube.com/@gilbertsahumada) verás la sintaxis completa y lo comprenderás mejor.

El resultado es un patrón intuitivo, donde todo empieza con un evento y termina con un resultado verificado criptográficamente.

Ejemplo en TypeScript:

```
cre.handler(
  cronTrigger.trigger({ schedule: “0 */10 * * * *” }), // cada 10 min
  onCronTrigger
)

function onCronTrigger(runtime: Runtime): Record {
  // lógica de negocio, tú lógica aquí
  return {}
}
```

##### Tipos de Triggers en CRE (cómo se gatilla un workflow)

Los workflows pueden ser iniciados por distintos eventos. Actualmente CRE soporte los siguientes tipos de triggers:

###### Triggers basados en tiempo (cron triggers)

Permiten ejecutar tu workflow según una programación fija usando expresiones CRON:

* cada X minutos

* una vez al día

* cada hora

* cada bloque (cuando se simule)

* horarios específicos

* intervalos regulares

Ejemplos:

```
cronTrigger.trigger({ schedule: “*/5 * * * * *” }) // cada 5 segundos
cronTrigger.trigger({ schedule: “0 0 * * *” })     // a medianoche
```

Este es el tipo trigger más común y se utilizaron Automation se les hará familiar porque tiene este y el trigger que viene.

###### Triggers por eventos on-chain (EVM log triggers)

Tu workflow puede escuchar eventos en una blockchain:

* transferencias

* swaps

* liquidaciones

* actualizaciones de precios

* cualquier evento emitido por un contrato en el fondo

Cada vez que el evento aparece en un bloque nuevo, CRE gatilla tu workflow

Ejemplo conceptual:

```
evmLogTrigger.trigger({
  chainId: 1,
  contractAddress: “0x...”,
  eventABI: “event PositionOpened(address user, uint amount)”
})
```

```
cronTrigger.trigger({ schedule: “*/5 * * * * *” }) // cada 5 segundos
cronTrigger.trigger({ schedule: “0 0 * * *” })     // a medianoche
```

Esto permite muchas posibilidades, tales cómo:

* liquidadores reactivos

* bots de MEV defensivo

* integración directa con dApps

* sistema de monitoreo

De hecho estoy preparando un video en dónde crearemos una stablecoin que se basa en este principio de <em>liquidador reactivo, </em>suscríbete a [mi canal](https://www.youtube.com/@gilbertsahumada) para que te enteres cuando lo publique.

###### Triggers HTTP (webhooks)

Tu workflow puede ser gatillado por una llamada HTTP entrante. Esto convierte CRE en un backend listo para integrarse con:

* sistemas Web2

* aplicaciones móviles

* plataformas institucionales

* backends tradicionales

* otras blockchains

Ejemplo:

```
httpTrigger.trigger({ method: “POST”, path: “/update” })
```

Esto convierte CRE en un microservicio web2/web3 serverless.

##### Cada trigger inicia una ejecución independiente

Cada vez que se un trigger se dispara:

* la DON detecta el evento

* inicia una ejecución nueva

* crea un contexto de Runtime nuevo

* ejecuta un callback desde cero

* ejecuta la lógica que hayas escrito

* obtiene resultados con consenso BFT

* <em>finaliza con un output independiente </em>(esto va cursivo porque dependiendo de lo que se ejecuta dentro del workflow podemos o no devolver un output arbitrario)

> Nota: los callbacks son <strong>stateless. </strong>No guardan información persistente entre ejecuciones.

Para estado persistente, simplemente puedes utilizar tu propia base de datos, o escribir en la blockchain, o utilizar un sistema de almacenamiento descentrlizado externo como Filecoin/IPFS. Y si, te menciono esto porque dentro de los workflows como se dijo mas arriba te permiten leer desde la chain, escribir en la chain y hacer llamadas HTTP (ejecución de APIs) y obtener un consenso BFT como consecuencia de estas ejecuciones.

#### Consensus Computing: seguridad institucional en cada paso

Cada capacidad ejecutada en CRE aplica automáticamente un protocolo de <strong>Byzantine Fault Tolerant (BFT) consensus</strong>.

Esto significa:

* múltiples nodos ejecutan la misma operación

* resultados independientes

* verificación criptográfica

* un resultado único, correcto y resistente a fallos

Veremos ejemplos prácticos en mi canal de youtube con lectura y escritura en la blockchain y llamadas HTTPs a sistemas externos.

Como puedes ver las posibilidades con CRE son infinitas, es como su pudieras armar legos, el mismo código funciona en distintas chains con una mínima configuración.

## <strong>Conclusión</strong>

<strong>Chainlink Runtime Environment</strong> marca un antes y después en la plataforma Chainlink.\
Transforma el sistema desde servicios preensamblados hacia una arquitectura modular donde los desarrolladores pueden construir workflows personalizados que combinan capacidades descentralizadas, APIs externas, cómputo off-chain y operaciones on-chain con garantías de consenso.

En definitiva:

> <strong>CRE es el puente universal entre blockchains, APIs, sistemas tradicionales e infraestructura institucional, todo bajo un mismo runtime verificable.</strong>

[Publicado originalmente en](https://gilbertsahumada.substack.com/p/chainlink-cre-en-espanol)
