Nexent
Build and deploy governed production AI agents from natural-language requirements.
Per-dimension scores and reasoning
Evidence shows deployment scripts support interactive confirmation (TUI) and defaults mode, but do not explicitly require user confirmation for external actions; sensitive information (e.g., registry passwords) is handled, but storage and transmission security are not detailed; dependency security includes some checks (e.g., path traversal rejection), but no dependency vulnerability scanning; external effects: deployment scripts pull and push images, but permissions are not explicitly limited; rollback: version management and history rollback are claimed, but no concrete implementation is provided; source attribution: copyright notice and contribution guide exist, but publisher is unverified. Therefore, scores are low.
Self-consistency: README, deployment scripts, and test files are largely consistent, but some inconsistencies exist (e.g., README mentions Docker Compose, but tests do not reflect it); dependency availability: external images and Hugging Face models are relied upon, but no availability guarantees are provided; failure messages: test scripts have clear error messages, but not all failure scenarios are covered.
Audience and scenarios: README clearly identifies individual/small team and enterprise scenarios, and provides Docker and Kubernetes deployment options; capability boundaries: core features are listed, but no explicit limitations; trigger precision: deployment scripts support various parameters and interactive modes, but trigger conditions are not explicit; environment fit: multiple architectures and deployment environments are supported, but detailed compatibility notes are missing.
Information architecture: README is well-structured with TOC and documentation links; install notes: detailed deployment steps and system requirements are provided; naming stability: project name and version naming are consistent; examples and FAQ: documentation links are provided, but no concrete examples; known limitations: not explicitly listed; license: MIT license is present; versioning and changelog: version statement exists, but no changelog; maintenance responsibility: contribution guide and security policy exist, but maintainers are not clearly identified.
Output usability: deployment and test scripts provide clear output and error messages; marginal value: zero-code platform and multiple features are offered, but no comparison with other platforms; cost-benefit: deployment options and resource requirements are provided, but no cost analysis.
Claim traceability: feature claims in README are not backed by concrete implementation or test evidence; cross-source corroboration: test scripts and documentation exist, but no independent verification; fact-inference separation: README claims are mostly assertions, without distinguishing facts from inferences.
- Publisher identity is unverified; treat with caution.
- Deployment scripts handle sensitive information (e.g., registry passwords); ensure secure transmission and storage.
- Reliance on external images and models; ensure supply chain security.
- Feature claims lack concrete implementation and test evidence; further verification is needed.
What does this agent do, and when should you use it?
Nexent is a zero-code agent platform built around Harness Engineering, combining tools, skills, memory, and orchestration. It is designed to turn a natural-language requirement into an executable agent, with agent versioning and history rollback. Its documented feature set includes A2A collaboration, two-tier persistent memory, progressive skill disclosure, knowledge-base retrieval, MCP extensions, and source-level citations. It can run on local or private infrastructure through Docker or Kubernetes, with both deployment paths using deploy/env/.env as their runtime configuration. It is best suited to teams that need self-hosting, multi-tenancy, and access controls rather than a standalone model chat interface.
Nexent takes natural-language agent requirements and generates executable agents. At runtime, it combines unified tools, Skills, two-tier memory, and orchestration; Progressive Skill Disclosure loads Skills into context dynamically, while the knowledge base imports more than 20 document formats for retrieval, automatic summaries, and cited answers. A2A Agent Collaboration supports distributed multi-agent workflows, and the MCP Tool Ecosystem connects custom and third-party MCP services. For delivery, bash deploy.sh docker forwards to deploy/docker/deploy.sh, while bash deploy.sh k8s uses deploy/k8s/deploy.sh; both read deploy/env/.env, and the Kubernetes path renders explicit settings into Helm ConfigMap and Secret overrides.
- An internal platform team that wants to create business agents from natural-language requirements in a private Docker environment, with version rollback available.
- A team coordinating several agents in a distributed workflow can use A2A Agent Collaboration for agent-to-agent cooperation.
- An operations or support team with substantial internal documentation can import it into a knowledge base and require source citations in responses.
- A product team that needs retained context at both the user and user-agent level can use the documented two-tier memory model.
- An organization serving multiple tenants and requiring role-based access and fine-grained knowledge-base controls can deploy it as a governed agent service.
- A development team that needs custom or third-party MCP services can extend agents through the MCP Tool Ecosystem.
What are this agent's strengths and limitations?
- It unifies tools, skills, memory, and orchestration under Harness Engineering, with documented constraints, feedback loops, and control planes.
- It offers both Docker and Kubernetes deployment paths using a shared deploy/env/.env configuration model for local or private infrastructure.
- A2A collaboration, progressive Skill loading, two-tier memory, MCP extensibility, and cited knowledge retrieval cover core components of multi-agent applications.
- Multi-tenancy, RBAC, agent versioning, and history rollback provide governance-oriented capabilities for organizational deployments.
- The minimum footprint is material: Docker requires at least 4 CPU cores, 8 GiB memory, and 40 GiB disk, while Kubernetes requires at least 16 GiB memory and 100 GiB disk.
- Kubernetes deployment requires Kubernetes 1.24+ and Helm 3+, plus storage decisions such as persistence mode, storage class, or local path.
- The supplied material does not specify model-provider credential fields, the detailed first-agent configuration flow, the management endpoint, or API examples, so implementation details need validation.
- Although optional components can reduce the footprint, application, data-process, and supabase are selected by default, so deployers must assess component scope.
How do you install or deploy this agent?
For Docker, install Docker 24+ and Docker Compose v2+, then provide at least 4 CPU cores, 8 GiB memory, and 40 GiB disk; the documented recommendation is 8 cores, 16 GiB, and 100 GiB. Run:
git clone https://github.com/ModelEngine-Group/nexent.git
cd nexent
bash deploy.sh dockerFor Kubernetes, install Kubernetes 1.24+ and Helm 3+, with at least 4 CPU cores, 16 GiB memory, and 100 GiB disk. Run:
git clone https://github.com/ModelEngine-Group/nexent.git
cd nexent
bash deploy.sh k8sDeployment preserves an existing deploy/env/.env; if absent, it first reuses docker/.env and otherwise uses deploy/env/.env.example. The supplied material does not document model-provider credential fields, a management URL, or first-login steps.
How do you use this agent?
After running bash deploy.sh docker or bash deploy.sh k8s, interactive deployment offers component, port-policy, and image-source selections. Use --defaults to skip the menu, or provide --version, --components, --port-policy development|production, and --image-source general|mainland|local-latest. infrastructure is mandatory; application, data-process, and supabase are selected by default but may be disabled. Product use is described as stating the desired agent in natural language and configuring the required knowledge base, Skills, MCP services, memory, and collaboration capabilities; the supplied material does not include a UI walkthrough or API example for creating the first agent.