Dans votre réseau. Appelable de l’extérieur.

Un système interne sans API devient un endpoint HTTPS. L’agent appelle vers l’extérieur et reste connecté ; une requête vers votre endpoint descend cette connexion, et le workflow s’exécute sur votre machine, contre un système que lui seul voit.

connexion ▸ un seul sens

L’agent appelle vers l’extérieur. Rien n’entre.

Tout repose sur une propriété : la connexion part de l’intérieur de votre réseau, vers l’extérieur, et reste ouverte. Le travail descend une connexion que vous avez déjà ouverte.

1. 01
   L’agent se connecte vers l’extérieur

   Vous installez l’agent sur une machine qui atteint déjà le système interne. Il ouvre une connexion sortante vers Writ et la maintient.

2. 02
   L’appel y descend

   Une requête vers votre endpoint publié passe par cette connexion existante. Writ n’ouvre pas de connexion vers votre réseau.

3. 03
   Le workflow s’exécute à l’intérieur

   Le navigateur pilote le système interne depuis cette machine : l’exécution voit exactement ce que verrait quelqu’un assis à ce poste.

pièces ▸ quatre

Ce qu’il faut.

Quatre éléments, chacun documenté sur sa propre page. Cette page donne l’ordre dans lequel les assembler.

mise en place ▸ dans l’ordre

Assemblez-le.

Chaque étape est du travail produit ordinaire — rien ici n’est propre aux systèmes internes, sauf l’endroit où se trouve l’agent.

1. 01
   Installez et liez l’agent

   Sur une machine dans le réseau. Une fois lié, il apparaît dans votre liste d’agents et maintient sa connexion sortante.

2. 02
   Apprenez le workflow

   Enregistrez la tâche contre le système interne, ou décrivez-la et laissez la session IA l’enregistrer. Les identifiants sont résolus depuis le coffre à l’exécution.

3. 03
   Pointez-le vers votre agent

   Réglez le workflow pour qu’il s’exécute sur votre agent plutôt que dans le cloud, afin que chaque exécution ait lieu sur une machine qui voit le système.

4. 04
   Publiez l’endpoint

   Choisissez la méthode et le chemin. Ce chemin devient l’API que le système interne n’a jamais eue.

5. 05
   Distribuez une clé consommateur

   Une clé par appelant. Limitez-la aux endpoints nécessaires, révoquez-la ou faites-la tourner sans toucher au workflow.

appel ▸ de n’importe où

Appelez-le comme n’importe quelle API.

Les appelants ne savent pas — et n’ont pas besoin de savoir — où l’exécution a lieu. Ils postent sur votre chemin avec leur clé et lisent le résultat.

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(())
}

partage ▸ qui fait quoi

Ce qui s’exécute où.

La séparation mérite d’être précise, car c’est elle qui rend l’exposition sûre.

limites ▸ ce qui plafonne

Les limites à connaître.

Voici les nombres qui décident du nombre de portes et de la force avec laquelle on peut y frapper.

référence ▸ le détail

Où chaque pièce est documentée.

questions ▸ posées

Uplink, en clair.

fin ▸ ouvrir une porte

Mettez un système interne derrière un endpoint.

Commencez par la mécanique des endpoints, puis décidez où l’exécution doit avoir lieu.