The Construct Image

What is the construct?

projectjackin/construct:trixie is the shared base Docker image for every agent. In The Matrix, the construct is the white void — the base simulation loaded before a mission. In jackin’, it’s the foundation layer that provides system tools, shell environment, and container infrastructure.

Every agent Dockerfile starts from the construct:

FROM projectjackin/construct:trixie

What’s inside

The construct is built on Debian Trixie and includes:

System tools

Package	Purpose
`bash`	Default shell for scripts
`zsh` + Oh My Zsh	Interactive shell with autosuggestions
`git` + Git LFS	Source control with large file support
`curl`	HTTP client
`jq` + `yq`	JSON and YAML processors
`openssh-client`	SSH for git operations
`sudo`	Privilege escalation (passwordless for claude user)
`tree`	Directory visualization

Search tools

Package	Purpose
`ripgrep` (`rg`)	Fast regex search
`fd-find` (`fd`)	Fast file finder
`fzf`	Fuzzy finder for interactive selection

Development infrastructure

Package	Purpose
`mise`	Polyglot language version manager
Docker CLI + Compose	Container operations via DinD
GitHub CLI (`gh`)	Repository, PR, and issue operations
Starship prompt	Informative terminal prompt

User environment

The construct creates a claude user with:

Home directory at /home/claude
Zsh as the default shell
Passwordless sudo access
Oh My Zsh with autosuggestions plugin
Starship prompt configured
mise shims in $PATH

How it’s built

The construct source code lives at docker/construct/ in the jackin’ repository. It’s automatically built and pushed to Docker Hub via GitHub Actions when changes are made to that directory.

The image is tagged as:

projectjackin/construct:trixie — the stable tag
projectjackin/construct:trixie-{sha} — commit-specific tags

The derived image layer

When you load an agent, jackin’ doesn’t use the construct directly. It generates a derived Dockerfile that adds:

User remapping — adjusts the claude user’s UID/GID to match your host user
Claude Code installation — installs the Claude Code CLI
Runtime entrypoint — the script that configures git, authenticates with GitHub, installs plugins, and launches Claude
Plugin installation — any Claude plugins declared in the agent manifest

Extending the construct

Agent repos add their tools on top of the construct. The construct provides the foundation — agents provide the specialization:

┌─────────────────────────────────┐
│  Derived Layer (jackin-managed) │  Claude Code, entrypoint, user mapping
├─────────────────────────────────┤
│  Agent Layer (your Dockerfile)  │  Rust, Node, Python, custom tools
├─────────────────────────────────┤
│  Construct (shared base)        │  Debian, git, Docker CLI, mise, zsh
└─────────────────────────────────┘

This layered approach means:

Agent authors focus on their tools, not infrastructure
The construct can be updated independently (security patches, new tools)
Docker layer caching makes builds fast