Dentro de tu red. Llamable desde fuera.

Un sistema interno sin API se convierte en un endpoint HTTPS. El agente llama hacia fuera y sigue conectado; una petición a tu endpoint baja por esa conexión, y el workflow se ejecuta en tu máquina contra un sistema que solo él ve.

conexión ▸ un sentido

El agente llama hacia fuera. Nada entra.

Todo se apoya en una propiedad: la conexión sale desde dentro de tu red, hacia fuera, y se mantiene abierta. El trabajo baja por una conexión que tú ya abriste.

1. 01
   El agente se conecta hacia fuera

   Instalas el agente en una máquina que ya alcanza el sistema interno. Abre una conexión saliente hacia Writ y la mantiene.

2. 02
   La llamada baja por ella

   Una petición a tu endpoint publicado pasa por esa conexión existente. Writ no abre ninguna conexión hacia tu red.

3. 03
   El workflow se ejecuta dentro

   El navegador maneja el sistema interno desde esa máquina, así que la ejecución ve exactamente lo que vería alguien sentado en ese puesto.

piezas ▸ cuatro

Lo que hace falta.

Cuatro elementos, cada uno documentado en su propia página. Esta página da el orden para montarlos.

montaje ▸ en orden

Móntalo.

Cada paso es trabajo de producto normal — nada aquí es propio de los sistemas internos salvo dónde está el agente.

1. 01
   Instala y vincula el agente

   En una máquina dentro de la red. Una vez vinculado aparece en tu lista de agentes y mantiene su conexión saliente.

2. 02
   Enseña el workflow

   Graba la tarea contra el sistema interno, o descríbela y deja que la sesión de IA la grabe. Las credenciales se resuelven desde el vault al ejecutar.

3. 03
   Apúntalo a tu agente

   Configura el workflow para que se ejecute en tu propio agente en vez de en el cloud, para que cada ejecución ocurra en una máquina que ve el sistema.

4. 04
   Publica el endpoint

   Elige el método y la ruta. Esa ruta se convierte en la API que el sistema interno nunca tuvo.

5. 05
   Reparte una clave de consumidor

   Una clave por quien llama. Limítala a los endpoints necesarios, y revócala o rótala sin tocar el workflow.

llamada ▸ desde cualquier sitio

Llámalo como a cualquier API.

Quien llama no sabe — ni necesita saber — dónde ocurre la ejecución. Hace un POST a tu ruta con su clave y lee el resultado.

curl -X POST https://api.usewrit.app/v1/acme/price-check \
  -H "Authorization: Bearer $WRIT_CONSUMER_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/product/42"}'

import os, requests

res = requests.post(
    "https://api.usewrit.app/v1/acme/price-check",
    headers={"Authorization": f"Bearer {os.environ['WRIT_CONSUMER_KEY']}"},  # csk_...
    json={"url": "https://example.com/product/42"},
    timeout=120,
)
res.raise_for_status()
payload = res.json()
print(payload["run_id"], payload["data"])

const res = await fetch("https://api.usewrit.app/v1/acme/price-check", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.WRIT_CONSUMER_KEY}`, // csk_...
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ url: "https://example.com/product/42" }),
});

if (!res.ok) throw new Error(`Writ call failed: ${res.status}`);
const { run_id, data } = await res.json();
console.log(run_id, data);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body, _ := json.Marshal(map[string]string{"url": "https://example.com/product/42"})
	req, _ := http.NewRequest("POST", "https://api.usewrit.app/v1/acme/price-check", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("WRIT_CONSUMER_KEY")) // csk_...
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var out struct {
		RunID string          `json:"run_id"`
		Data  json.RawMessage `json:"data"`
	}
	json.NewDecoder(res.Body).Decode(&out)
	fmt.Println(out.RunID, string(out.Data))
}

use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("WRIT_CONSUMER_KEY")?; // csk_...
    let res: Value = reqwest::Client::new()
        .post("https://api.usewrit.app/v1/acme/price-check")
        .bearer_auth(key)
        .json(&json!({ "url": "https://example.com/product/42" }))
        .send()
        .await?
        .error_for_status()?
        .json()
        .await?;

    println!("{} {}", res["run_id"], res["data"]);
    Ok(())
}

reparto ▸ quién hace qué

Qué se ejecuta dónde.

Vale la pena ser preciso con esta separación, porque es lo que hace segura la exposición.

límites ▸ qué topa

Límites que conviene saber.

Estos son los números que deciden cuántas puertas abres y con qué fuerza pueden llamar.

referencia ▸ el detalle

Dónde está documentada cada pieza.

preguntas ▸ frecuentes

Uplink, respondido.

fin ▸ abrir una puerta

Pon un sistema interno detrás de un endpoint.

Empieza por la mecánica de los endpoints y luego decide dónde debe ocurrir la ejecución.