4,194,304-token context Industry-leading agentic model for long, stateful tool-use workflows where continuity across many steps matters.
Build tools once. Let every model and system use them.
Run Nexum as the agent, the tool-building specialist behind another model,
or the shared execution layer for an entire model fleet.
Nexum is an agentic NoNE model family built to turn intent into verified
action. It combines strong function calling with planning, long-context
reasoning, tool execution, internal coordination, self-correction, and durable
workflows so developers can build agents that do more than produce text.
Give Nexum an objective and a workspace. It can inspect the available tools,
choose and sequence actions, use observations to repair a failed approach,
verify the result, and return a grounded response. The same release runs as a
local CLI, an NNF X agent harness, an HTTP server, or a self-contained Docker
service.
Nexum is also a capability builder for other models and systems. Connect an
existing model, agent, application, or automation platform through
OpenAI-compatible tools, MCP, A2A, HTTP, or the CLI. Nexum can discover a
missing capability, create and version a workspace-local tool, execute it,
verify the result, and return a correlated observation to the calling system.
The validated tool remains available for later work instead of disappearing
with the prompt that created it.
NoNE means Nest of Native Experts. The complete model coordinates its
native authorities through its trained recurrent path instead of depending on
a host-authored dispatch table.
Most agent stacks assume every required connector, function, and workflow was
known before deployment. Nexum adds a different operating model: start with
the tools you trust, discover what the task actually needs, and build the
missing capability when evidence shows a real gap.
Use Nexum in three complementary roles:
Role
What Nexum does
Best fit
Universal tool model
Reasons, selects tools, acts, verifies, self-corrects, and completes the objective
Standalone local or hosted agents
Tool-building specialist
Creates, tests, versions, upgrades, retires, and reuses workspace-local tools for another model
Existing model fleets that need a stronger action layer
Shared agent runtime
Serves the same capability catalog through OpenAI-compatible, MCP, A2A, HTTP, CLI, and NNF X surfaces
Platform teams standardizing execution across clients and applications
Discover - inspect supplied functions, the runtime catalog, language
packs, repository state, and workspace-local capabilities.
Define - create a strict schema and a contained implementation from
safe workspace commands instead of emitting an imaginary result.
Execute - run the tool under the same workspace, policy, approval,
secret-redaction, and call-correlation boundaries as shipped tools.
Verify - treat real output, artifacts, tests, and exit state as evidence;
keep the objective open when the result is unresolved.
Correct - feed an authenticated failure into the next model attempt so
the correction addresses the action that actually failed.
Retain - keep integrity-checked tool generations and history for reuse,
upgrade, retirement, rollback, and later sessions in the same workspace.
Serve - make the capability available to other models and systems
through Nexum's portable agent and tool interfaces.
The caller does not need to be Nexum. A general-purpose model can delegate a
missing action to Nexum over A2A, consume Nexum's tool catalog over MCP, submit
OpenAI-style function schemas to NNF X, or use the authenticated HTTP service
as a capability backend. Nexum returns actions and observations with exact call
correlation rather than asking the caller to trust an ungrounded summary.
From AI Pilot To Agentic Operations
Nexum addresses the practical business cases that decide whether agents stay
in demos or become reusable infrastructure:
Business case
Nexum capability
How teams use it
AI transformation
Prompt-to-action workflows with templates, tools, verification, and resumable state
Move employees from chat-only assistance to delegated, evidence-backed work in the clients and systems they already use
AI platform
One model and runtime surface for tool discovery, execution, correction, and capability growth
Provide a common action layer to multiple models, agents, applications, and teams instead of rebuilding tool glue for each one
On-demand agents
Task-specific NNF X and A2A sessions with durable objectives, artifacts, and model-owned completion
Launch a focused agent from a prompt, invoke it interactively or from an external scheduler, and resume the same open task after interruption
Reusable capability catalog
Shipped tools, language packs, templates, dynamic tools, version history, and integrity checks
Turn internal commands, APIs, runbooks, and repeatable workflows into capabilities that other agents can discover and reuse
Model and client interoperability
OpenAI-compatible chat and tools, MCP, A2A, HTTP, CLI, and caller-owned function schemas
Keep the preferred model or client while using Nexum for missing tools, verified execution, or complete delegated work
Attach operational boundaries before actions reach files, terminals, repositories, browsers, or external services
Identity and delegation integration
Bearer authentication, session namespaces, call identifiers, signed observations, and delegated-agent context
Place Nexum behind an existing identity or API gateway while preserving who requested work, which session acted, and which result belongs to which call
Keep credentials and private control state out of model-visible output while requiring consequential actions to satisfy policy and approval
Tool-sprawl migration
Repository and filesystem inspection plus catalog comparison and tool lifecycle operations
Analyze supplied client configs and tool inventories, identify duplicated or missing capabilities, and promote approved patterns into reusable workspace tools
Observability and adoption
Ordered events for actions, tasks, approvals, artifacts, failures, corrections, and outcomes
Export evidence into existing analytics, audit, or security systems to see what is used, where work stalls, and what capability should be improved next
Durable automation
Long-running tasks, cancellation, content-addressed artifacts, process restart recovery, and no fixed tool-step limit
Run research, data, terminal, and operational workflows that outlive one request without losing their execution record
Learn from real execution outcomes without copying benchmark answers, mixing users, or silently rewriting the read-only release
Built to complement your existing control plane
Nexum does not require a company to replace its preferred models, clients,
identity provider, gateway, scheduler, SIEM, or analytics stack. Deploy it
behind those systems as the model-directed capability and execution layer:
AI and transformation teams publish reusable templates, tools, and
delegated workflows instead of repeating one-off agent setup.
Platform teams expose one consistent tool and agent surface to many
models while retaining strict schemas and result correlation.
IT and security teams keep authentication, network policy, identity, and
enterprise audit controls at the perimeter while Nexum enforces workspace,
approval, redaction, and execution boundaries inside the runtime.
Engineering and operations teams get verified terminal, repository,
browser, data, artifact, and long-running task workflows rather than another
text-only assistant.
Model builders and application developers can use Nexum as a specialist
that creates and operates tools their primary model does not have.
This makes Nexum useful both as a complete agentic system and as infrastructure
that increases the capability of models already deployed across an
organization.
From Intent To Verified Action
Tool use is Nexum's execution layer, not the limit of its capability. Nexum is
designed for work where reasoning and action must stay connected:
Tool-first execution: select functions, construct arguments, coordinate
sequential or parallel calls, and ground the next decision in real results.
Adaptive objectives: keep multi-stage work open, revise the plan when the
environment changes, and verify completion instead of stopping at a draft.
Self-correction: feed authenticated execution failures back into the same
session so the next attempt can address what actually went wrong.
Durable improvement: retain verified outcomes in an operator-owned state
namespace without mixing projects or users.
Long-context work: operate across large repositories, documents, logs,
and ongoing sessions with a native 4,194,304-token context window.
Coordinated problem solving: combine specialized capabilities for
research, drafting, implementation, challenge, and review.
Self-built tools on demand: when the catalog has a gap, Nexum can
compose, run, verify, and retain a new workspace-local tool instead of
stalling or inventing a fake result.
When The Tool Does Not Exist Yet
Most models stop when the toolkit is incomplete. Nexum keeps going.
If a required capability is missing, Nexum inspects the live tool catalog,
detects the gap, and can build its own reusable tool from safe workspace
commands. It does not pretend the action succeeded. It creates the tool,
executes it, verifies the observation, and keeps the validated definition for
the next turn — and the next project session in that workspace.
That means Nexum is not limited to the tools you remembered to ship on day one.
It can extend its own action surface mid-task:
Gap detection — notices when no supplied tool covers the needed action
Tool creation — registers a reusable local command tool for that capability
Immediate execution — runs the new tool and treats the result as evidence
Self-correction — revises the next action if the first attempt fails
Durable retention — upgrades, reuses, and promotes validated tools instead
of recreating them blindly every time
Governed improvement — promotions and rollbacks stay receipt-backed, so
new capabilities remain auditable
This is the difference between a model that calls tools and a model that can
grow its toolkit when the work demands it.
Industries + ICP Use Cases
Finance
For finance teams, Nexum is built to remove expensive handoffs across risk, compliance, and operations by running evidence-backed checks, verifications, and corrective loops inside one trusted workflow. Teams use it for faster investigations, steadier operations, and cleaner audit trails where every action is tied to observed outcomes, with typical gains in cycle-time and operator load from reduced rework.
Healthcare
For healthcare teams, Nexum helps coordinate high-context operations that mix records, queue state, and procedural steps by executing tool actions, validating results, and only advancing when evidence supports completion. This reduces coordination lag across care and admin teams and gives cleaner, faster follow-up for repetitive operational workload.
Software
For software teams, Nexum turns code and platform workflows into an execution loop instead of one-shot suggestions: it can inspect code, run checks, recover from failures, and keep an evidence-linked session for next-step action. This pattern reduces context loss between assistants, operators, and systems while improving engineering throughput on recurrent tasks.
Manufacturing
For manufacturing teams, Nexum is useful for operations loops where response quality is tied to action quality: telemetry checks, maintenance sequencing, incident triage, and status consolidation can be executed and re-routed automatically when outcomes fail. Teams typically gain reliability and lower rework by keeping the loop anchored on measured outcomes rather than manual guess-and-repeat.
Capabilities by Use Case
Ask, Act, Verify, Improve: Nexum receives a task, executes tool actions, verifies outcomes, and retries intelligently when a result is incomplete or wrong.
Tool Execution First: The model decides what to run and why, then runs it with your local tool set and returns what actually happened.
Build Missing Tools: When a capability gap appears, Nexum can create, run, verify, and retain a new workspace-local tool instead of stopping short.
Equip Other Models: Existing models and agents can delegate missing capabilities to Nexum or call the runtime through OpenAI-compatible, MCP, A2A, HTTP, and CLI surfaces.
Reusable Tool Lifecycle: Workspace tools retain integrity-checked generations so teams can describe, upgrade, retire, restore, and reuse capabilities safely.
Portable Agent Backend: Use Nexum as a complete agent, a specialized worker, or a shared tool service behind the applications and AI clients already deployed.
Long-Context Control: Handles large context windows where decisions depend on history, artifacts, and state continuity.
Session-Scoped Memory: Keeps work cleanly separated by namespace so teams can run multiple live projects without cross-mixing decisions.
Reliable Correction: Failed actions become correction evidence for a real next step, reducing repeated failure loops.
Governed Execution: Strict schemas, risk-scoped policy, exact approvals, secret redaction, and signed receipts keep real actions inspectable.
Operational Visibility: Ordered task, action, approval, artifact, correction, and outcome events can feed existing audit and observability systems.
Deployment-Ready Integration: Drop into CLI, server, MCP/A2A, or Docker flows with explicit authentication and operational control.
Compliance-Ready Output: Returns tool-grounded progress and durable receipts for review, auditability, and governance.
BFCLv4
Full Nexum scores 91.92%.
BFCLv4 function-calling: Nexum 91.92% (+11.9 percentage points over the next public comparison recorded for this release)
What You Can Build
Use case
What Nexum brings
Coding and repository agents
Repository inspection, reproduction, patching, testing, review, and verified handoff
Research agents
Long-context evidence gathering, source comparison, synthesis, and grounded reporting
Operations assistants
Log and state inspection, runbook execution, incident triage, approvals, and durable receipts
Tool and API agents
Structured function selection, argument construction, parallel calls, retries, and result validation
Model-fleet capability service
Create and operate missing tools for other models through OpenAI-compatible, MCP, A2A, HTTP, or CLI integrations
Internal capability catalog
Package commands, APIs, runbooks, and workflows as versioned workspace tools with discovery and integrity history
Governed agent platform
Combine authenticated endpoints, strict schemas, one-shot approvals, redaction, session isolation, and signed observations
On-demand delegated agents
Start task-specific work from another client or model, preserve state, and resume after interruption
Tool inventory and migration
Inspect supplied client configurations and catalogs, identify gaps or duplication, and convert approved patterns into reusable capabilities
Adoption and audit workflows
Export ordered action, task, approval, artifact, failure, and outcome evidence to existing operational systems
Document and data workflows
Extraction, transformation, cross-document reasoning, artifact creation, and quality checks
Persistent project agents
Resumable tasks, isolated state, self-correction, and retained verified improvements
Choose Your Nexum
The repository contains three complete, independently loadable profiles. The
profile names describe operating emphasis; none is a partial tensor package.
Broader long-running objectives, coordinated development, durable correction, and autonomous operations
Every profile includes its own:
model/safetensors/000001.safetensors through 000113.safetensors
model/tensor_map.json, which is the supported load order
tokenizer, chat template, and generation configuration
release-local Nexum runtime
NNF X harness, server, tools, templates, and operating notes
Fastokens integration with exact token-ID parity checks
Do not mix numbered files between profiles or load a hand-selected subset. A
profile is complete only when its map and all 113 numbered packages validate.
The supported release layout is profile-based. Integrations should load one
complete mapped profile folder rather than relying on legacy flat root files.
Download
Authenticate with a token that has repository read access, then download without
placing that token in a script or image.
hf download namenotfoundai/Nexum --include "Nexum-Universal/**" --repo-type model --local-dir ./Nexum
The Hub records profile acquisition from each profile's required model
configuration. No extra telemetry request or manual counter file is needed.
Local Installation
Python 3.12, an NVIDIA CUDA environment, and enough free GPU memory for the
selected profile are required. A 96 GB-class GPU is recommended for full GPU
residency. Install the runtime supplied with the selected profile:
The runtime installs Fastokens and loads the selected profile's own byte-level
BPE vocabulary, merges, normalizer, special tokens, and chat template. Cold
loading compares accelerated token IDs with the packaged tokenizer and fails
closed if parity changes.
CLI
Use chat for a completion and agent for the model-directed NNF X tool loop:
bash
1nexum chat \2 --model ./Nexum-Universal/model \3 --device cuda:0 \4 --prompt "Summarize the current directory."56nexum agent \7 --model ./Nexum-Universal/model \8 --device cuda:0 \9 --workspace ./workspace \10 --tools \11 --prompt "Inspect this project, run its tests, and report verified failures."
Useful discovery and operations commands include:
bash
1nexum tools list
2nexum capabilities
3nexum language-packs --query python
4nexum templates list
5nexum tasks list --workspace ./workspace
6nexum events --workspace ./workspace
7nexum status self-correction
8nexum status self-improvement
No completion-token or tool-step limit is added unless a caller explicitly
supplies one. Runtime completion remains confidence-driven.
Server
The server validates every numbered package before accepting work. A
non-loopback server and all HTTP tool execution require a bearer API key:
GET /health, /v1/models, /tools, /capabilities, and /templates
POST /v1/chat/completions and /v1/responses
POST /agent/run for the complete NNF X action loop
POST /tools/execute for authenticated caller-directed execution
POST /mcp and /a2a for protocol integrations
task, event, artifact, approval, correction, and improvement status surfaces
OpenAI-compatible chat example:
bash
1curl http://127.0.0.1:8080/v1/chat/completions \2 -H "Authorization: Bearer $NEXUM_API_KEY"\3 -H "Content-Type: application/json"\4 -d '{
5 "model": "Nexum-Universal",
6 "messages": [{"role": "user", "content": "Inspect the workspace and summarize its current state."}],
7 "temperature": 0
8 }'
NNF X example:
bash
1curl http://127.0.0.1:8080/agent/run \2 -H "Authorization: Bearer $NEXUM_API_KEY"\3 -H "Content-Type: application/json"\4 -d '{
5 "prompt": "Inspect the repository, run the relevant checks, and return the verified result.",
6 "workspace": "/workspace",
7 "session_id": "project-a"
8 }'
NNF X returns signed action observations to the same model session. A failed
action becomes self-correction evidence for the next forward. A second verified
failure can create durable self-improvement state for later work in the same
operator-owned namespace. The harness never substitutes a host-selected answer
or repair action for the model's selection.
Containers
Four self-contained image targets are supplied. Model files are embedded in
the images; no model bind mount or runtime repository download is required.
Compose profiles are also available. Start only one service on a host port at a
time:
bash
1NEXUM_API_KEY="replace-with-a-long-random-value"\2docker compose -f containers/compose.yaml --profile universal up universal
See containers/README.md for image construction,
OCI export, profile selection, persistence, and security details.
Tools, Templates, And State
Nexum includes terminal, filesystem, repository, web, browser, artifact,
durable-task, source-intelligence, drafting, reproduction, triage, disclosure,
and transactional patching tools. The included templates provide reusable
starting points for common call shapes without deciding which tool the model
must choose.
Beyond the shipped catalog, Nexum can also author its own tools when it
detects a capability gap: create a workspace-local tool, run and verify it,
upgrade a staged candidate, and retain the validated definition for later work.
New tools stay outside the read-only model bundle, so the release artifact
remains immutable while the action surface can still grow with the task.
The model folder is read-only. Sessions, receipts, approvals, user-created
tools, and verified improvement state live in the external state and workspace
volumes. Keep each operator or project in its own NEXUM_STATE_NAMESPACE to
avoid cross-project state mixing.
Security
Never bake HF_TOKEN, NEXUM_API_KEY, source credentials, or private
workspace data into an image.
Keep the model directory read-only and persist state separately.
Expose a tool-enabled server only behind authentication and network controls.
Review approval records before consequential actions.
Use distinct state namespaces for distinct operators or trust domains.
License
Nexum is released under the permissive open-source
Nexum Open Attribution License 1.0. You may use, modify,
redistribute, host, sublicense, sell, and build commercial or non-commercial
derivatives from the complete release. Copies and derivatives must retain the
license and attribution. Commercial products, services, and hosted deployments
must display the attribution in a reasonable visible location.
Required attribution:
Powered by Nexum from NameNotFound.ai. Nexum was created by Wendell Adams.
https://namenotfound.ai
NoNE was invented by Wendell Adams. Nexum is released by
NameNotFound.ai.
Citation
bibtex
1@misc{namenotfound_nexum_2026,
2 title = {Nexum: A NoNE Model Family for Tool-Directed Work},
3 author = {Adams, Wendell},
4 year = {2026},
5 organization = {NameNotFound.ai},
6 note = {Nexum-Lite, Nexum-Universal, and Nexum-Expanded}
7}
Run Nexum
Start with one profile. Nexum-Lite is the tool-calling-first choice;
Nexum-Universal is the balanced default. Substitute Nexum-Expanded when
that profile is available in your release.
