4 GB memory · 40 GB storage
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.
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.
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.
- STEP 1Prepare isolated infrastructure
Allocate the console and development host, define DNS and TLS, and document allowed inbound and outbound routes.
- STEP 2Verify 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.
- STEP 3Configure Git and model access
Use scoped credentials, decide where model requests go, and verify that secrets do not appear in task output or logs.
- STEP 4Run an acceptance task
Clone a non-sensitive repository, build it, run tests, inspect the diff, and confirm that another reviewer can reproduce the result.
- STEP 5Plan 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.")
PYPackage 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 architecture | Measured package | Download requested (UTC) | Preparation requested (UTC) |
|---|---|---|---|
amd64monkeycode-online-linux-amd64.tgz | 6377747 bytes SHA-256 6dd439a994920e435137101a8953ec0843131110f07eb6ef48877c98d05344c4 | exit 0 | |
arm64monkeycode-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
- Read the official entry only as text; require the reviewed version and HTTPS package host/path.
- Measure compressed bytes and SHA-256 before opening the archive. Require one directory and six regular files; reject duplicates, links and other members.
- Check manifest version, architecture and online type, then hash Compose before extracting any files.
- 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.
- Official entry (read as text) ↗
- Upstream repository ↗
- Download measured record (JSON)
- Read-only verifier (Python)
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 arm64A 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.shReproduce 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.
Model APIs, Git hosts, package registries, previews, updates, and telemetry.
Administrator access, repository credentials, model keys, rotation, and revocation.
Task-to-task, project-to-project, host, filesystem, process, and network isolation.
Logs, retention, backups, restore tests, upgrades, rollback, and vulnerability response.
Validate security and capacity before adding production code.
Installation FAQ