MaaEnd: a MaaFramework-based automation assistant for Arknights: Endfield

What MaaEnd automates in Arknights: Endfield

MaaEnd is an in-game task runner for Arknights: Endfield. The README lists the concrete jobs it performs: daily reward collection, protocol space stamina spending, ecological farm planting and watering, matrix farming and matrix filtering, puzzle solving, environment monitoring, warehouse transfers, blueprint importing, credit store shopping, friend visits and bulk friend requests, delivery jobs, and commission grabbing. It also covers combat assistance (auto attack, dodge, skill and ultimate casting, target focus), auto dialogue skipping with branch selection, auto pickup, and auto medicine use.

The audience is a player who already runs the game and wants the repetitive layer removed. It is not a general RPA tool and not a bot framework you point at arbitrary games. Every capability in the list is tied to Endfield's UI, which is why the repository is dominated by pipeline definitions and resource assets rather than reusable libraries. If you want to automate a different game, MaaFramework is the layer you would target; MaaEnd is a finished consumer of it.

How the client, pipeline assets and Go agent fit together

The repository layout shows the split clearly. The default branch is v2, and the top level contains assets/, agent/, tools/, docs/, tests/, plus maatools.config.mts, package.json and pyproject.toml. The README states the project is powered by MaaFramework and MXU. That means the recognition and input layer is MaaFramework, the user-facing shell is MXU, and MaaEnd supplies the Endfield-specific content: pipeline JSON under assets/resource/pipeline and a Go service under agent/go-service.

The tooling is a second layer. package.json defines scripts such as generate:AutoDelivery, generate:DeliveryJobs and generate:EnvironmentMonitoring. Several of them fetch data first (fetch:zmdmap), then run sync scripts, then run a generator. That pattern suggests route and catalog data for delivery and environment monitoring is derived from an external map source rather than hand-maintained. pyproject.toml confirms the split: it declares dependency groups named schema, pipeline, images, map-navigator and scripts, with maafw pinned as maafw>=5.12,<6.0 in the pipeline group and maafw>=5.13.0b4,<6.0 in the map-navigator group. The go-service directory is referenced by the format:go script, which runs go fmt inside agent/go-service.

One consequence worth stating plainly: the pipeline JSON is data, not code. If a generator script changes, the generated pipeline changes, and behaviour shifts without any change to the Go binary. That is a maintainability trade-off, not a defect. It makes bulk edits cheap and makes diffs noisy.

Installing MaaEnd and running a first preset

The README does not give build-from-source instructions for end users. It points to the official site: "请前往 MaaEnd 官网 下载最新版本", which is to say, download the latest version from https://maaend.com/. The README also states that new versions update automatically, so there is no manual upgrade step described for the client. If you are on Android, the README lists ADB support; on PC it lists Win32 foreground.

What follows is the developer-side setup that the repository files do describe, not an end-user install. The project uses pnpm for Node scripts and uv for Python. The pyproject.toml defines console scripts including build-and-install and setup-workspace, and the default uv group is scripts.

pnpm install
uv sync

The first command installs the Node toolchain declared in package.json; the second resolves the Python groups from pyproject.toml, which pulls in maafw and the image and map-navigator dependencies. After that, the check and test entry points are the ones the repository declares:

pnpm check
pnpm test

Both delegate to maa-tools, a dependency named in the scripts block. If you are only using the released client, none of this is required. The README's user path is the download page, and the developer path is the docs index at docs/zh_cn/developers/README.md.

Where MaaEnd breaks or is the wrong choice

The README is unusually direct about the first limitation: it calls the project one that is being iterated on quickly and says small bugs may appear. That is a maintenance signal, not a marketing line, and it should shape expectations. The last push to the repository was on 2026-08-28, the same date as release v2.26.0, with v2.26.0-rc.1 and v2.26.0-beta.7 landing in the days before. A project shipping a beta, a release candidate and a final within three days is moving fast enough that pinned behaviour is unlikely.

The second limitation is platform coupling. The README lists PC (Win32 foreground) and Android (ADB). Win32 foreground means the game window needs to be visible and focused, which rules out running it on a headless machine or alongside other fullscreen work. ADB means an Android target with debugging enabled. Neither path is a Linux-native desktop story, and the README does not describe one.

Third, the generator scripts depend on an external map source. fetch:zmdmap is a prerequisite for generate:AutoDelivery and generate:EnvironmentMonitoring. If that upstream data changes shape, the sync and generate steps fail before any pipeline is produced. Anyone building from source inherits that dependency; users of the released client do not see it, but they do inherit the results of it.

Finally, this is the wrong tool if you want a stable API. There is no library contract here. The Go code under agent/ is a service, the pipeline JSON is generated data, and the README's own framing is a client you download.

MaaEnd against MaaFramework and MXU directly

The honest alternative is not another Endfield bot; it is the stack MaaEnd is built on. MaaFramework handles recognition and input, and MXU provides the interface. Using those directly gives you a general automation framework with no Endfield knowledge: you would write your own pipeline for every task MaaEnd already ships. The difference in approach is that MaaEnd is a content project. Its value is the accumulated pipeline JSON and the Go agent that encodes Endfield-specific logic, plus the generator scripts that keep route data in sync.

That also means the comparison cuts the other way. If Endfield changes its UI, MaaEnd has to update assets and regenerate pipelines. A framework user with a small custom pipeline only fixes their own. Conversely, a framework user gets nothing for free, while MaaEnd ships dozens of named tasks in the README. Choosing between them is choosing between maintenance you inherit and maintenance you write.

Within MaaEnd itself, the alternative to the released client is building from source with the pnpm and uv toolchain. That path is documented for developers, not users, and it exposes you to the external map fetch step. For most players the client is the right entry point.

Maintenance cost, licence and what to verify

MaaEnd is licensed AGPL-3.0. The practical implication for anyone modifying and distributing it, or running a modified version as a network service, is that the AGPL's source-availability terms apply. This is not legal advice; read the LICENSE file in the repository and get proper counsel if you plan to ship a derivative.

Upgrade cost is low for end users by design. The README states that new versions update automatically, so there is no documented manual upgrade procedure for the client. The cost sits with contributors instead: the pipeline JSON is formatted by a dedicated script (format:aggressive, run before format), which suggests the generated files are large enough to need their own formatting pass. Regenerating them means running the fetch, sync and generate chain in the right order, and that chain depends on an external map source.

The maintenance signal from the repository itself is recent activity: the last push was on 2026-08-28, and the v2.26.0 release carries the same timestamp. That is a current project, but the README's own warning about rapid iteration means you should treat any specific task behaviour as provisional and check the release notes for the version you install.

Editorial conclusion

MaaEnd is for Endfield players who want routine tasks (dailies, base logistics, matrix farming, puzzle solving) driven by a client they download rather than assemble. It is not for anyone who wants a stable, frozen tool: the README describes the project as under rapid iteration and warns of bugs, and the pipeline JSON and generator scripts under tools/ change often. Before adopting it, verify the client version against release v2.26.0, confirm your platform path (PC Win32 foreground or Android ADB), and read the AGPL-3.0 terms if you intend to redistribute or modify anything.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes