Pajé
Beta available · Codex is the first harness

Durable orchestration piloted by the agent

From request to pull request. Without losing the thread.

Pajé was designed to be piloted by the agent itself through harness hooks and skills. It turns every change into a verifiable, repository-language-neutral workflow: the right context, isolated execution, human approval, and idempotent publication.

Agent-piloted designHooks + skillsLanguage-neutralCodex first
RUN / CODE-CHANGE@V1client-timeout-20260725
awaiting approval
resolvecompleted
executecompleted
approvaldecision needed
publishqueued
finalizequeued
Verified artifact42.8 KB
sha256:8d7a4e...bf31
7 files18 checks0 secrets
Agentmodel: hooks + skills
Genericchecks for any stack
Codexfirst harness
5durable phases

The agent pilots. Pajé sustains.

Autonomy without
losing the process.

The harness preserves agent autonomy; Pajé provides a predictable contract for effects. Hooks and skills are the intended integration surface. Every action leaves evidence, and every retry knows where to continue.

01product direction

Designed for the agent to pilot

The product model puts harness hooks and skills at the entry point, so the agent itself can invoke the protocol, follow the run, and resume with context.

02any stack

Repository-language-neutral

Workflows are repository-language-neutral. Pajé happens to be implemented in Go, but Go-native positioning is inconsequential; the generic profile runs structured checks for any stack available in the worker image.

03restart-safe

Durable execution

Each phase persists its state. Retries resume the right work without relaunching the agent or duplicating effects.

04Mem0 adapter

Scoped memory

The agent receives relevant context by user and application. Worker credentials stay outside the execution.

05content-addressed

Verifiable artifact

Patch, output, verification, and preflight become an immutable bundle authenticated by SHA-256.

06artifact-bound

Bound approval

The human decision applies to one exact run and digest. If the artifact changes, the approval no longer applies.

07idempotent

Deterministic PR

Branch, commit, and pull request are reused only when every binding matches. No force-push.

08Codex first

Replaceable harness

Codex is the first supported harness. The execution boundary is designed to support other harnesses in the future without changing the durable protocol.

code-change@v1

A workflow that knows
where it stands.

The agent starts and follows the work through the harness integration. Hatchet handles the queue, retries, and signals; Pajé owns the contract: state, context, artifacts, policy, and publication.

01

Resolve

Establish the truth

Validates the input, reserves the idempotency key, and resolves the ref to an immutable commit.

02

Execute

Build and prove

Prepares an isolated worktree, retrieves memory, runs the agent, and verifies every selected module.

03

Approval

Request a decision

Pauses durably and waits for approval bound to the artifact's exact digest.

04

Publish

Publish without surprises

Reapplies and reverifies the bundle before creating or reusing a deterministic draft PR.

05

Finalize

Close the loop

Writes one outcome to memory and returns durable references for auditing.

Quick guide

From trigger to first run.

The beta is a self-hosted worker. Codex is the first harness; the protocol was designed to support others in the future.

01

Prerequisites

Prepare the ground

Go 1.26+ is required only to develop Pajé, which happens to be implemented in Go; Go-native positioning is inconsequential. The target repository can use any language: include its toolchain in the worker image. For the beta, prepare Docker, Helm 3, Hatchet, and Codex authentication.

Any stackDockerHelm 3HatchetCodex · first harness
02

Installation

Build and install

Build the image with an auditable revision and apply the chart after configuring separate Secrets.

terminalbash
git clone https://github.com/araihu/paje.git
cd paje

PAJE_COMMIT="$(git rev-parse --verify 'HEAD^{commit}')"
docker build \
  --build-arg CODEX_VERSION=0.144.5 \
  --build-arg PAJE_COMMIT="$PAJE_COMMIT" \
  -t ghcr.io/your-org/paje:beta .

helm upgrade --install paje ./charts/paje \
  --namespace paje --create-namespace \
  --values values.production.yaml
View the complete installation and Helm values
03

First run

Start an artifact run

Today, start paje-code-change-v1 in Hatchet. The intended integration will move this trigger into harness hooks and skills. Use profile: generic with explicit checks and the toolchain present in the image. The go profile is only a convenience for module discovery and test defaults.

workflow-input.jsonjson
{
  "run_id": "73f659b2-eaee-4c37-8784-48fab274b3e8",
  "input": {
    "idempotency_key": "client-timeout-20260725",
    "task_description": "Increase the client timeout and update the tests.",
    "repository_uri": "https://github.com/example/service.git",
    "base_ref": "main",
    "memory_query": "HTTP client conventions",
    "memory_limit": 5,
    "tags": {
      "user_id": "operator@example.com",
      "app_id": "service"
    },
    "profile": "generic",
    "checks": [
      {
        "name": "test",
        "executable": "npm",
        "args": [
          "test"
        ],
        "timeout": "10m",
        "required": true
      }
    ],
    "publication": {
      "mode": "artifact"
    }
  }
}
04

Publication

Approve the artifact, not the intent

To create a draft PR, use publication.mode: pull_request. The approval phase waits for the event paje:approval:<run-id> with the same run and digest. If anything changes, the decision is not reused.

View the approval event contract

Security through boundaries

The agent sees what it needs.
The system keeps sensitive data safe.

Hatchet, Mem0, and GitHub credentials never enter the agent environment. Publication happens in a new trusted bare repository after repository-controlled code has been verified.

Read guarantees and conflict behavior
worker boundaryservice credentials
P/Agent runtime
  • selected memory
  • isolated worktree
  • allowed environment
  • × worker tokens

Documentation

Understand the contract.
Operate with confidence.

Open the complete README
Betascope

Today Pajé provides the typed code-change@v1 template, the Codex runner as the first harness, Hatchet triggering, artifact or GitHub draft PR mode, and one replica. Agent-side hooks and skills and other harnesses will be supported in the future. Automatic merge, arbitrary YAML, releases, and multiple replicas are outside this beta.

The agent pilots through hooks and skills.
Pajé makes the journey durable.

Autonomy for any stack.
Codex first, more harnesses later.