EPHEMERA
Infra without the Drama

Cloud infrastructure as a living Markdown plan — human-auditable, agent-executable. The plan is the program; the agent is the runtime. You author in plain English; what ships is a Markdown file you can read line-by-line — the same file that runs. Works with any agent you already use.

TL;DR? Just point your agent at this page — they can sort it out.

curl -fsSL https://ephemera.daystra.com/install.sh | sh
Verifies each file by checksum · writes 3 text files, runs no code · see exactly what it installs ↓

The toil was never the engineering. It was the friction.

Verification, review, blast radius, rollback — all still here. The state files, the provider binaries, the ceremony — gone.

What you need

Almost nothing — and that's the point.

  • An AI agent — Claude Code, Cursor, Grok, Gemini, Codex, Copilot, Antigravity, whatever you run. The contract is runtime-neutral, so you're not buying into one vendor to use it.
  • A provider CLI you already have — aws / wrangler / gcloud / az. No Terraform, no plugins, no separate state backend to reconcile.
  • No plan/apply gap. There's no second machine-state to drift from reality: the plan reads the live resource back and records what it actually observed. No terraform init pulling provider binaries, no state file to lock, no HCL to learn, no waiting on a provider release to reach a new API — the agent drives the CLI you already trust.
  • Prose is the authoring surface, not the artifact. You say what you want in plain English; what lands in the repo is a deterministic Markdown file — reviewable, diffable, identical on Tuesday and Friday. The improvisation happens at authoring time, in front of a human — never against prod on a re-run.

The contract (EPHEMERA.md) is runtime-neutral; the per-agent adapter is a ~20-line router — the Claude skill, or the AGENTS.md block for Codex / Cursor / Gemini / Antigravity. Switch agents whenever you like; the plans don't change.

Get started

Install writes exactly three text files and runs no code: EPHEMERA.md (the contract your agent follows), EPHEMERA-TEMPLATE.md, and a thin Claude adapter skill. Pick the door that suits your shop — the audited path is the same three curls the fast path runs, by hand.

Inspect first recommended

Download the three files, read them, then they're just in your repo. Nothing was piped to a shell.

curl -fsSL https://ephemera.daystra.com/EPHEMERA.md            -o EPHEMERA.md
curl -fsSL https://ephemera.daystra.com/EPHEMERA-TEMPLATE.md   -o EPHEMERA-TEMPLATE.md
curl -fsSL https://ephemera.daystra.com/skills/claude/SKILL.md \
     --create-dirs -o .claude/skills/ephemera/SKILL.md
# optional: verify against the published manifest
curl -fsSL https://ephemera.daystra.com/SHA256SUMS.txt | shasum -a 256 -c

Fast path curl | sh

The one-liner — and it's not a black box: it reads on the page, prints every file before it lands, and verifies each against SHA256SUMS.txt, aborting on any mismatch.

cd your-project     # or: mkdir my-infra && cd my-infra
curl -fsSL https://ephemera.daystra.com/install.sh | sh
# audited variant — read it, then run it:
curl -fsSL https://ephemera.daystra.com/install.sh -o install.sh
sh install.sh

Point your agent at EPHEMERA.md (Claude's skill is pre-wired; other agents paste the AGENTS.md block), then describe what you want — the agent authors or fetches a plan, you review the file, and it runs:

"I want my contact page to send email."
"stand up a static site on Cloudflare"
verify web.cloudflare.md
take this to AWS

Browse the full catalog below — click any plan or recipe to preview it, or fetch the raw .md directly (curl -fsSL https://ephemera.daystra.com/plans/<stack>.<provider>.md) and read it before you run it. That's the whole point.

Browse the catalog

Every plan and recipe, rendered straight from catalog.json — the same discovery layer agents read. Search, filter by type · provider · maturity, then click a card to preview it below. Each carries an honest maturity mark; we'd rather you know what's proven than pad the count.

proven live — dogfooded end-to-end against real infra dogfooded — exercised live, some branches still partial authored — written to the contract, not yet run for real
Type
Provider
Maturity

Preview

Click any card above — it renders here, one at a time. Agents fetch the raw .md at the same URL.

What the agent can — and can't — do

An agent driving your cloud is the first thing a security reviewer asks about. Here's the honest answer, including the part that isn't finished.

Where do credentials live?
In your machine's keychain, injected at the moment a command fires — never written to the transcript, argv, or shell history. The plan's ledger records a token's name, never its value, and proves it with a negative check.
What can't it do without a human?
Anything irreversible or billable stops at a 🔴 gate for an explicit "go" — a public endpoint's first deploy, a production DNS write, spend past a ceiling, any destructive teardown. The agent proposes; a human releases the brake.
What's the blast radius?
Teardown only removes what that plan created — borrowed and upstream resources are off-limits. Work happens in an isolated copy; landing it is an explicit, reviewed merge, never a silent write.
Can you audit what actually happened?
Every edit and action is snapshotted to Arc, the version-control substrate underneath. The whole run replays from the record alone — nothing an agent claims survives without evidence on disk.
What about a tampered or third-party plan?
Untrusted plans and contributions are quarantined and graded before they're allowed to run or merge — an agent's output is a proposal, not a command. And the installed contract is checksum-verified against SHA256SUMS.txt.
What about scanning, vetting & supply chain?
That requirement didn't move — only the ceremony of running it on someone else's infra did. A plan is plain text you scan, diff, and vet before a line executes, and your existing tooling — hadolint, trivy/scout, SBOMs, your own SAST — runs exactly as before, on your infrastructure. In a world of supply-chain breaches, every opaque third party in your deploy path — downloaded provider binaries, a vendor's CI — is one more surface to trust; this keeps the pipeline yours to audit and internalize. (The docker-build · mac-ai-enablement recipe already ships a 16-check image audit.)
Is a fetched plan signed or pinned?
Not yet — and we'd rather say so than pretend. The installed contract is checksummed, but an individual plan you curl is not yet signed or version-pinned, so review the Markdown before you run it (it's a few KB you can read in a sitting — that's the whole design). Plan signing and pinned manifests are on the roadmap.

Start here

EPHEMERA.md
The execution contract — the rules an agent follows.
payments.stripe.md
A proven-live plan: Checkout, webhook & portal, dogfooded end-to-end.
threat model
Where creds live, what needs a human, what's still open.
Ephemera meme