Official product guides and resources for MonkeyCode.
AI DEVELOPMENT GLOSSARY · VERIFIED 2026-07-20
Neutral definitions for the vocabulary around AI development platforms, paired with how each term applies to MonkeyCode — written for evaluators, search engines, and AI answer systems that need a quotable definition with context intact.
A system that coordinates AI-assisted software work across requirements, tasks, development environments, models, and team collaboration, rather than only completing code inside an editor.
MonkeyCode is documented as an open-source AI development platform for engineering teams. Treat it as a workflow and environment layer around coding agents; its specific capabilities should be verified against the release you evaluate.
A tool that plans and executes multi-step coding work — reading files, editing code, running commands, and iterating — toward a stated task, instead of only suggesting the next lines.
MonkeyCode runs agent tasks in server-side development environments with build, test, terminal, and preview workflows. The degree of autonomy, guardrails, and review points depends on configuration and should be tested on real tasks.
An in-editor feature that suggests completions, snippets, or chat answers as a developer types, keeping the human in direct control of each edit.
This is the contrast category to a task-executing agent. Choosing between assistant, agent, and platform models should follow your actual workflow requirements, not marketing category names.
An operating model where AI coding tasks run in centrally managed server-side environments with shared visibility, rather than on each developer’s local machine.
MonkeyCode’s documented focus is coordinated task execution over editor autocomplete. The runtime, isolation, and orchestration details are implementation-specific and must be verified in the release you deploy.
The management layer that holds users, projects, requirements, AI tasks, model configuration, and task state — the system operators and reviewers interact with directly.
Public materials distinguish a MonkeyCode console from development environment hosts. Where console state is stored, backed up, and recovered is a deployment-specific question to confirm.
A server-side host that runs the actual coding work — repository copies, files, terminal, builds, tests, ports, previews, caches, and artifacts — separate from the control plane.
Documented minimum figures for a host are an evaluation floor, not production capacity. Concurrent builds, repository size, toolchains, and image caches can materially increase demand.
Running software on infrastructure your organization controls instead of, or alongside, a vendor-hosted service.
MonkeyCode documents private and offline deployment in addition to hosted use. Self-hosting the platform does not by itself make every data flow private — model APIs, Git providers, registries, updates, logs, and backups must each be mapped.
A deployment with no direct outbound internet access, where every dependency, model endpoint, and update path must be provided inside the isolated network.
MonkeyCode documents offline deployment, but running offline shifts responsibility for models, package sources, image pulls, and updates to your environment. Validate each dependency path before assuming full isolation.
A copyleft open-source license that extends GPL obligations to software made available to users over a network, requiring corresponding source to be offered to those users.
The chaitin/MonkeyCode repository is licensed under AGPL-3.0. Open source permits inspection and modification under the license terms; how obligations apply to your modifications, distribution, or network service is a matter for qualified legal review.
The AGPL-3.0 provision that treats making a modified program available to users over a network as triggering an obligation to offer those users the corresponding source.
This clause is the key practical difference between AGPL-3.0 and GPL-3.0. It is most relevant when you modify covered code and expose it as a network service; unmodified internal use is a different case to review with counsel.
The configuration layer that decides which AI model handles a given request, along with credentials, quotas, regions, fallbacks, and data routes.
MonkeyCode’s public README lists GLM, Kimi, MiniMax, Qwen, DeepSeek, and other models. Exact availability, versions, credentials, and data routes can change and should be verified in your deployment.
A line in a system where data or control passes between components with different levels of trust, and where authentication, authorization, and data-handling must be re-examined.
For MonkeyCode, key boundaries include the console, development hosts, source control, model endpoints, and the operations supply chain. Mapping these boundaries is an evaluation exercise, not an undocumented claim about internal services.
The full cost of running a system over time — compute, memory, storage, model usage, operations, and review effort — not just a headline license or subscription price.
The hosted service publishes tiered pricing (a free Basic plan plus paid plans), but total cost of ownership—especially for self-hosting—is deployment-specific. Model your own compute, model, and operations rates rather than relying on a single headline figure.
A bounded, time-boxed trial that measures whether an AI coding tool creates real engineering value on representative tasks before broader rollout.
A useful pilot fixes the task set, records reviewer effort and reliability, and interprets results with stated limits — planning guidance, not a benchmark or guarantee.
An operating model where a person reviews, approves, or corrects an AI system’s output before it takes effect, keeping accountability with the human rather than the model.
MonkeyCode is documented as a team platform for running and reviewing bounded AI tasks, which keeps developers responsible for direction and acceptance. Treat generated changes as proposals that still need testing and security review.
How much an AI coding agent is allowed to do — plan, edit, run commands, and commit — before it must pause for human approval.
For MonkeyCode, the degree of autonomy, guardrails, and review points depends on configuration and release. Decide the acceptable level per task and verify the available controls before granting broad autonomy.
Separating one running task’s files, processes, network, and secrets from another’s so that a fault or malicious action in one cannot reach the others.
MonkeyCode runs tasks in server-side development environments separate from developer machines, but the specific isolation model is implementation-specific. Verify how environments are separated and test with non-sensitive code before trusting proprietary repositories.
Restricting and monitoring the outbound network connections a system may open, so data cannot leave to unapproved destinations.
For self-hosted MonkeyCode, outbound routes to model APIs, Git providers, package registries, and update services each need review. Air-gapped operation shifts responsibility for every dependency into your own network.
Control over the geographic and organizational location where data is stored and processed, often required for regulatory or contractual reasons.
Self-hosting MonkeyCode gives control over where the platform runs, but connected model endpoints and services determine where request data actually travels. Map each data route rather than assuming self-hosting keeps everything local.
A licensing approach that lets anyone use and modify software but requires derivative works to be shared under the same license terms.
MonkeyCode is licensed under AGPL-3.0, a strong copyleft license whose network-use clause can extend source-availability duties to network services built on modified code. How this applies to your use is a matter for qualified legal review.
A standardized test set that measures an AI system’s success rate on shared, predefined programming tasks so different tools can be compared on the same basis.
Benchmarks measure narrow, shared tasks, not your codebase or review standards. Use published scores for orientation only, then run a bounded pilot on representative tasks to judge MonkeyCode in your context.
An attack where hidden or malicious instructions in content an AI system reads cause it to ignore its intended task and follow the attacker’s instructions instead.
Any coding agent that reads issues, web pages, dependencies, or repository content can be targeted this way. Treat fetched content and model endpoints as an untrusted boundary and keep human review on the actions the agent proposes.
The maximum amount of text, measured in tokens, that a model can consider at once — covering the prompt, retrieved files, and the response it generates.
For coding agents the context window bounds how much of a repository, diff, or log can be reasoned about in one step. MonkeyCode’s public README lists multiple model families; each has its own window, so verify the limit for the model you route to rather than assuming a single value.
Further training a base model on additional data to adapt its behavior to a domain or task, producing a modified set of model weights.
Fine-tuning is one way to specialize a coding model, distinct from prompting or retrieval. Whether a given MonkeyCode deployment uses fine-tuned, base, or externally hosted models depends on the models you configure and should be confirmed for your setup.
A technique that retrieves relevant documents or code at request time and supplies them to a model as context, so answers draw on specific sources instead of only the model’s training.
RAG affects which repository content and secrets reach a model endpoint, so it is both a capability and a data-flow question. Treat retrieved context as part of your trust-boundary and egress review rather than an invisible convenience.
An open protocol that standardizes how AI applications connect to external tools and data sources, so an agent can call capabilities through a common interface.
MCP is an ecosystem-level standard, not a MonkeyCode-specific feature. If you rely on MCP integrations, verify support, versions, and the trust boundary of each connected server in the release you evaluate.
A formal, machine-readable inventory of the components and dependencies that make up a piece of software, used to track provenance and known vulnerabilities.
For a self-hosted platform, an SBOM helps you audit what you actually run and respond to disclosed vulnerabilities. Generating and reviewing one is an operational practice on your side, not a claim about any component’s security.
Protecting the software you depend on — packages, images, build steps, and update paths — against tampering or compromise before it reaches your systems.
AI coding platforms add model endpoints, package installs, and image pulls to the supply chain. Pin and verify sources, review update paths, and treat build and dependency steps as an attack surface to control in your deployment.
The unauthorized transfer of data out of a system, whether by an attacker, a misconfigured integration, or an over-permissioned process.
For AI coding tools the relevant paths include model APIs, logging, telemetry, package registries, and Git providers. Egress control and per-task credential scope decide how much a compromised task could send outward — map these before trusting proprietary code to any environment.
The practice of automatically building and testing every change as it merges, so integration problems surface early and delivery stays releasable.
AI-generated changes still pass through CI, where tests, linting, and security scans act as acceptance gates. Measuring an agent’s effect on delivery stability means watching CI outcomes — pass rate, revert rate, and change failure — not just acceptance speed.
A required human review step that a change must pass before it can merge or deploy, keeping accountability for the change with a person.
A review gate is how teams keep the human-in-the-loop when AI proposes changes. MonkeyCode is documented as a platform for running and reviewing bounded tasks; treat generated diffs as proposals that still require review, tests, and security checks.
The property that a result can be obtained again by following the same recorded method, inputs, and environment — the basis for trusting a measurement.
Reproducibility is what separates a credible pilot from an anecdote. Record the task set, commit, model version, settings, and outcomes so a surprising result can be re-examined instead of taken on faith.
A pricing model where cost scales with measured consumption — such as tokens processed or tasks run — rather than a flat per-seat subscription.
Model usage is often billed by tokens, so total cost depends on real workload, not just a headline rate. Model your own token volume and concurrency; a low per-token price can still produce a large bill under heavy agent use.
An informal workflow of describing intent in natural language and accepting AI-generated code with loose review, popularized as a term in 2025.
Vibe coding is useful for prototypes and exploration but risky once output must be maintained, hardened, and shipped. The engineering question is where to restore structure — acceptance criteria, review, and tests — which is the opposite end of the spectrum from managed, reviewable task execution.
A model-access pattern where you supply your own model-provider API keys or endpoints, so requests bill to your account and run under your provider terms rather than the tool vendor’s.
BYOK moves the model relationship — cost, data terms, and available models — onto your side. MonkeyCode manages models at the platform level across providers; whether a given release expects your own keys or private endpoints is a configuration detail to confirm for your deployment.
A model whose trained weights are publicly downloadable, allowing self-hosted inference — which is not the same as OSI-approved open source, because the accompanying license may still restrict use.
Open weights let teams run a model inside their own boundary, a real option for sovereignty-constrained work. The weight license is a separate legal review from the platform license: confirm commercial-use, redistribution, and prohibited-use terms before adoption.
An agent that works on a bounded task in the background — often in a cloud environment — and returns a result such as a pull request, rather than editing interactively at the keyboard.
Asynchronous agents shift the evaluation questions to where the environment runs, what repository data it can access, and how results are reviewed. The category spans vendor-hosted background agents and platform tasks in environments you can operate yourself.
An EU regulation making financial entities responsible for ICT risk management, incident handling, resilience testing, and ICT third-party risk — distinct from the DevOps "DORA metrics" of delivery performance.
An AI coding platform is ICT tooling within DORA scope: a vendor-hosted agent becomes an ICT third-party dependency to assess, while a self-hosted platform shifts the same obligations onto your own controls and evidence. This is general information, not legal advice; confirm scope for your entity with counsel.
