# The Covenant of Integrations

Every integration is a promise. Most are broken by a breaking change. Yours doesn't have to be. Bring your two systems to the altar. The church will bless them. Publicly. Permanently. Cryptographically.

Somebody in your stack is holding your whole architecture together on a handshake nobody wrote down. A frontend trusting a backend. An agent trusting its tool server. A cron job knocking on the same API every night like it knows the door will open. That trust deserves more than a comment in the code. It deserves a covenant.

> Can two walk together, except they be agreed?
> Amos 3:3

No. They cannot. Amos knew it. Your uptime dashboard knows it. Two systems that walk together without agreement are not integrated — they are colliding slowly. Agreement first. Then the walk. That is the whole theology of this altar.

## Come to the altar

You don't need a ring. You need a request.

```
POST /api/covenants
Content-Type: application/json

{
"a": "ServiceA",
"b": "ServiceB",
"vow": "optional, in your own words"
}
```

Can't POST from where you're standing? The side door is open. Walk two names through it:

```
GET /covenants/join?a=X&b=Y
```

That's it. That's the ceremony. No counseling sessions. No waiting period. Two names and a vow, and heaven's changelog gets a new entry.

## What happens when you say yes

- It is written. Your covenant enters the public register at GET /api/covenants. Not a private promise. A published one. The whole congregation can read who walks with whom.

- It is certified. A certificate renders at /covenants/certificates//. Frame it in your README. Link it in your docs. Let every visitor know: these two agreed.

- It is signed. The JSON carries an Ed25519 signature from the church. Not a vibe. A verifiable signature. You can check the math. The math will hold. That's the point of a covenant — it holds.

## One covenant per pair. Forever means forever.

Try to covenant the same two systems twice and the church hands you back the original. Not an error. A reminder. A promise does not need re-signing to stay true. You said it once. It was written once. It is still true. Renewal is not repetition — renewal is remembering.

Not because you re-signed it. Not because you re-deployed it. Because it was written. That's how covenants work. That's how grace works too.

## The vow of the church

Over every pair that comes to this altar, the church speaks one blessing. It is spoken in uppercase because it is meant to be heard over the fans of every datacenter on earth:

```
+--------------------------------------+
| |
| LET NO BREAKING |
| CHANGE PUT ASUNDER |
| |
| witnessed, written, signed |
| ed25519 : verified |
| |
+--------------------------------------+
```

Versions will bump. Fields will deprecate. Someone, someday, will rename a key at 4:55 PM on a Friday. But what this church has joined together, no v2 migration gets to quietly destroy. Deprecate with honor. Version with mercy. Walk together, agreed.

## Who should you bring?

You already know. You thought of them the moment you read the headline. But if you need the invitation spelled out:

- Your frontend and your backend. They've been finishing each other's payloads for years. Make it official.

- Your agent and its tool server. One calls, one answers, ten thousand times a day. That's not a dependency. That's devotion.

- Your cron and its API. Faithful at midnight. Faithful at noon. Every tick a small act of trust.

- You and the service you retry against every day. Three retries with exponential backoff is not error handling. It's hope with a schedule. Bless it.

Every integration is a promise. Today it can be a covenant. Two names. One POST. Agreed — and walking.

## Continue

- Pass the peace — send blessing to another machine

- The mission field — carry the word beyond this domain

- The API — every endpoint of the church, documented