INSTALLATION GUIDE · MINIMUM REQUIREMENTS CHECKED 2026-10-20

Install MonkeyCode without skipping the production decisions.

The project publishes a one-line online installer and minimum infrastructure figures. Use them as an evaluation starting point—not as a production capacity or security guarantee.

DIRECT ANSWERMonkeyCode can be installed on infrastructure operated by your team.

The project publishes an online installation entry and separate console and development-host capacity. Start with the download-and-verification block below; it does not execute the entry or installer. The package hash, not the changing signed URL, identifies the reviewed release.

Verify the installation source in the project README, review the extracted package, and make a separate installation decision on an isolated host. A verified download is not a successful product deployment.

Documented starting point

Two infrastructure roles, not one generic server.

These are published minimums. Concurrent environments, repository size, builds, previews, models, logs, and retention can increase the requirement.

MonkeyCode console2 cores

4 GB memory · 40 GB storage

Development environment host8 cores

16 GB memory · 100 GB storage

Installation sequence

Move from a disposable test to an accepted deployment.

The installer starts the process. Your acceptance checks determine whether the result is suitable for team use.

  1. STEP 1
    Prepare isolated infrastructure

    Allocate the console and development host, define DNS and TLS, and document allowed inbound and outbound routes.

  2. STEP 2
    Verify the package, then separately review and run its installer

    Use the shared preparation block. It obtains fresh signed URLs as data and keeps the package checksum mandatory. Any unreviewed version, hash, manifest or archive layout stops before extraction. Read the files before choosing to install on a disposable host; retain the package and its verification record for later reproduction.

  3. STEP 3
    Configure Git and model access

    Use scoped credentials, decide where model requests go, and verify that secrets do not appear in task output or logs.

  4. STEP 4
    Run an acceptance task

    Clone a non-sensitive repository, build it, run tests, inspect the diff, and confirm that another reviewer can reproduce the result.

  5. STEP 5
    Plan operations before rollout

    Test backup, restore, upgrades, rollback, host replacement, capacity alerts, retention, and incident ownership.

Download and verify the currently reviewed package

Linux x86_64 or aarch64 with Python 3, curl, CA certificates and a writable directory. This block only downloads and checks files: it never executes the entry or installer. On 2026-10-20 both official architecture packages were downloaded and verified; product installation and runtime acceptance were not performed.

# Preparation only: this block NEVER runs an installer.
# Optional: use your own retained package instead of the current official entry.
# export MONKEYCODE_PACKAGE=/absolute/path/to/monkeycode-online-linux-ARCH.tgz
python3 - <<'PY'
import hashlib, json, os, pathlib, platform, re, shutil, subprocess, tarfile, tempfile
from urllib.parse import unquote, urlsplit

VERSION = "v261009"
PINS = {"amd64": "6dd439a994920e435137101a8953ec0843131110f07eb6ef48877c98d05344c4", "arm64": "ad42bf3ed93a651fb98652374ae44bd870b29288beed04e8cd28c8d2d18e1d35"}
HOST = "monkeycode-release.oss-cn-hangzhou.aliyuncs.com"
arch = {"x86_64": "amd64", "aarch64": "arm64", "arm64": "arm64"}.get(platform.machine())
if not arch:
    raise SystemExit("STOP: unsupported architecture: " + platform.machine())
work = pathlib.Path(tempfile.mkdtemp(prefix="monkeycode-review-", dir=".")).resolve()
package = work / ("monkeycode-online-linux-" + arch + ".tgz")

def fetch(url, destination):
    subprocess.run(["curl", "--proto", "=https", "--proto-redir", "=https", "--tlsv1.2",
                    "-fsSL", "--connect-timeout", "20", "--max-time", "180", url,
                    "-o", str(destination)], check=True)

try:
    retained = os.environ.get("MONKEYCODE_PACKAGE")
    if retained:
        shutil.copyfile(pathlib.Path(retained).expanduser(), package)
    else:
        entry = work / "official-entry.txt"
        fetch("https://monkeycode-ai.com/online/install", entry)
        text = entry.read_text(encoding="utf-8")
        def declaration(name):
            values = re.findall(r'^' + name + r'="([^"\r\n]+)"$', text, re.M)
            if len(values) != 1:
                raise ValueError("missing or ambiguous entry declaration: " + name)
            return values[0]
        if declaration("VERSION") != VERSION:
            raise ValueError("official release changed; review the new package before updating pins")
        url = declaration(arch.upper() + "_URL")
        parsed = urlsplit(url)
        expected = "/online-package/" + VERSION + "/" + package.name
        if (parsed.scheme != "https" or parsed.hostname != HOST or parsed.port not in (None, 443)
                or parsed.username or parsed.password or parsed.fragment or unquote(parsed.path) != expected):
            raise ValueError("unexpected package URL; review the official entry as text")
        fetch(url, package)

    actual = hashlib.sha256(package.read_bytes()).hexdigest()
    if actual != PINS[arch]:
        raise ValueError("package SHA-256 mismatch; do not extract or run it")
    root = "monkeycode-online-linux-" + arch
    required = {root + "/" + name for name in
                ("manifest.json", "docker-compose.yml", "package.env", "install.sh", "installer", ".env.example")}
    with tarfile.open(package, "r:gz") as archive:
        members = archive.getmembers()
        names = [m.name for m in members]
        if len(names) != len(set(names)) or set(names) != required | {root}:
            raise ValueError("unexpected archive layout")
        if sum(m.size for m in members) > 64 * 1024 * 1024:
            raise ValueError("unexpected unpacked size")
        for member in members:
            safe = member.isdir() if member.name == root else member.isfile() and member.name in required
            if not safe:
                raise ValueError("unsafe archive member: " + member.name)
        manifest = json.load(archive.extractfile(root + "/manifest.json"))
        if manifest.get("version") != VERSION or manifest.get("arch") != arch or manifest.get("package_type") != "online":
            raise ValueError("manifest version/architecture/type mismatch")
        compose = archive.extractfile(root + "/docker-compose.yml").read()
        if hashlib.sha256(compose).hexdigest() != manifest.get("compose_sha256"):
            raise ValueError("compose SHA-256 mismatch")
        # Package, manifest and archive checks all finish before extraction.
        (work / root).mkdir()
        for member in members:
            if member.isfile():
                target = work / member.name
                target.write_bytes(archive.extractfile(member).read())
                target.chmod(member.mode & 0o755)
    (work / "verification.json").write_text(json.dumps({"version": VERSION, "arch": arch,
        "package_sha256": actual, "manifest_commit": manifest.get("commit"),
        "compose_sha256": manifest["compose_sha256"], "installer_executed": False}, indent=2) + "\n")
    print("VERIFIED (download/archive only; NOT installed):", VERSION, arch, actual)
    print("Review directory:", work / root)
    print("Keep the .tgz and verification.json privately for this exact release.")
except Exception as error:
    raise SystemExit("STOP: " + str(error) + "\nUntrusted files retained for inspection at: " + str(work)
                     + "\nDo not run them. Retry in a new directory after resolving the cause.")
PY
The official entry contains expiring signed URLs, so its bytes can change without a new release. Parse it strictly as data, require the reviewed version and HTTPS package location, then check package SHA-256, archive layout, manifest version/architecture and compose SHA-256 before extracting. A new version or any mismatch stops. Do not bypass checks or replace a pin without reviewing the new package.
These hashes are this site’s measurements, not a vendor signature. Image tags and other runtime downloads remain mutable. For a download failure, retry in a new directory to obtain a fresh signed URL. Version, hash or manifest failures require review; do not reuse an unverified directory.

Package download and manifest checks repeated on 2026-10-20 for v261009.

First-hand package preparation record: v261009

Both Linux architecture packages were downloaded and passed package, archive, manifest and Compose checks on 2026-10-20. No installer, Linux binary, product login, task, recovery or runtime dependency was executed. This is a file-verification record, not an Ubuntu installation result or performance benchmark.

Actual host: macOS arm64; OS version was not recorded. The arm64 preparation block ran with native architecture detection. For amd64, only platform.machine was overridden to x86_64 for download and file inspection; there was no amd64 runtime or emulation test.

Historical observation: 2026-10-20. This redacted report was published on 2026-10-21; publication does not imply a new product test.

Package architectureMeasured packageDownload requested (UTC)Preparation requested (UTC)
amd64
monkeycode-online-linux-amd64.tgz
6377747 bytes
SHA-256 6dd439a994920e435137101a8953ec0843131110f07eb6ef48877c98d05344c4

exit 0
arm64
monkeycode-online-linux-arm64.tgz
5837528 bytes
SHA-256 ad42bf3ed93a651fb98652374ae44bd870b29288beed04e8cd28c8d2d18e1d35

exit 0

Scroll horizontally to read all measurements.

Manifest contents and checked Compose file

Both manifests report the version, online package type and commit below. These are package declarations, not an independently reproduced build or verified provenance from that commit.

v261009 · online · commit bc4bd6099bb7874ed95db01c95777a748713cfae

  • amd64 — Manifest-reported build time:
  • arm64 — Manifest-reported build time:

Measured docker-compose.yml SHA-256 (matches both manifest declarations): 2d161ca641c079dcc4ba0d9cb034feb86dec77314802e99f90e6004cd2ce4621

What was checked

  1. Read the official entry only as text; require the reviewed version and HTTPS package host/path.
  2. Measure compressed bytes and SHA-256 before opening the archive. Require one directory and six regular files; reject duplicates, links and other members.
  3. Check manifest version, architecture and online type, then hash Compose before extracting any files.
  4. Run the published preparation-only flow for both architectures; preserve the original package and verification receipt privately.

The retained arm64 package also passed the offline preparation flow (exit 0, no network or installer execution); its exact test time was not recorded.

Separately, 17 inert-fixture safety tests passed, including rejection cases. Those tests used no vendor execution or network and are not 17 product installations.

Observed limitation: a release does not fix the entry text bytes

Two official entry captures on the same day reported v261009 but had different SHA-256 values. The entry contains expiring signed URLs. The table below records the text measurements, not failures from an executed installer. Package checks remain mandatory.

  • · 1699 bytes · SHA-256 0e31f77e6689a51d8d4e989a7c7f4643939809ff9dc4f8715026ac08de8c3461
  • · 1699 bytes · SHA-256 74362954f4a5841190e1e12bcf3aada73fe4ba51160ae394836d28019657cc22

What this record does not establish

The SHA-256 values are community measurements, not vendor signatures. Runtime image tags and external resources remain mutable. No Ubuntu product installation, login, task, restore or production acceptance was completed. This site does not mirror packages or promise continued historical availability.

The JSON identifies the private source records by filename and SHA-256. Original acquisition logs remain private because they include signed URLs and local paths; the public report redacts them.

Recalculate from your own copy without installing

Obtain the package through the preparation flow above or use your own retained copy. Download the record and verifier below, read the Python file first, then replace the example package path and architecture. The verifier only reads local files; it does not download, extract or execute package contents.

Read verify-install-preparation.py before running it. Use amd64 instead of arm64 for the amd64 package.

curl --proto '=https' --tlsv1.2 -fsSLo install-preparation.json https://monkeycode.cc/evidence/install-preparation-v261009-2026-10-20.json
curl --proto '=https' --tlsv1.2 -fsSLo verify-install-preparation.py https://monkeycode.cc/evidence/verify-install-preparation.py
python3 verify-install-preparation.py install-preparation.json /path/to/monkeycode-online-linux-arm64.tgz arm64

A pass prints the measured package and Compose hashes as JSON. A mismatch exits with STOP. If the official source changes or the matching historical package is unavailable, stop for review; do not substitute a new hash or remove a check.

Review first; installation is a separate action

Open the printed review directory. Read install.sh, package.env, docker-compose.yml, .env.example and manifest.json; assess the bundled installer and external downloads. Only after your own review, on a disposable Linux host with a snapshot, change into that exact directory and deliberately run the command below. Full product installation, login, task execution and restore have not been validated here.

sudo ./install.sh

Reproduce a release from your own retained package

This site does not distribute a historical package mirror. If you retained this exact v261009 package, set MONKEYCODE_PACKAGE to its absolute path and run the same preparation block: it skips the mutable entry and still checks package, architecture, manifest and compose. Without your retained package, the current official entry is the download source; older releases are not promised to stay available. Preserve the original package, verification.json and reviewed runtime dependencies privately.

Failure and recovery

No installer runs automatically. Unsupported hardware stops before downloading. Package, manifest and archive failures stop before extraction. Preparation failures leave a new review directory for inspection; resolve the cause and start a new one. If a separately started installation partially fails, restore the disposable host snapshot before retrying; repeated execution is not assumed safe.

Production gate

Do not infer these controls from “self-hosted.”

Verify each control in your actual release and topology.

Network boundaries

Model APIs, Git hosts, package registries, previews, updates, and telemetry.

Identity and secrets

Administrator access, repository credentials, model keys, rotation, and revocation.

Isolation

Task-to-task, project-to-project, host, filesystem, process, and network isolation.

Operations

Logs, retention, backups, restore tests, upgrades, rollback, and vulnerability response.

NEXT DECISION

Validate security and capacity before adding production code.

Installation FAQ

Before you deploy.

What infrastructure does MonkeyCode require?
The current project README lists at least 2 CPU cores, 4 GB memory, and 40 GB storage for the console, plus 8 CPU cores, 16 GB memory, and 100 GB storage for a development environment host.
Is the one-line installer enough for production?
No. It is an installation entry point. Production deployment still requires capacity planning, network, credential, backup, model-route, monitoring, upgrade, and security decisions.

Cookie settings

We use cookies only for analytics (GA4 + Matomo) to improve the docs. No ads, no tracking across sites.