Nexum

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.

NameNotFound.ai | NoNE Collection | Contact

Give Every Model A Toolkit That Can Grow

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

Your model, agent, application, or workflow
                    |
     OpenAI tools | MCP | A2A | HTTP | CLI
                    |
             Nexum + NNF X
                    |
 discover -> select -> build -> execute -> verify -> retain
                    |
        signed observations and durable receipts

A complete missing-tool lifecycle

1. Discover - inspect supplied functions, the runtime catalog, language packs, repository state, and workspace-local capabilities.
2. Define - create a strict schema and a contained implementation from safe workspace commands instead of emitting an imaginary result.
3. Execute - run the tool under the same workspace, policy, approval, secret-redaction, and call-correlation boundaries as shipped tools.
4. Verify - treat real output, artifacts, tests, and exit state as evidence; keep the objective open when the result is unresolved.
5. Correct - feed an authenticated failure into the next model attempt so the correction addresses the action that actually failed.
6. Retain - keep integrity-checked tool generations and history for reuse, upgrade, retirement, rollback, and later sessions in the same workspace.
7. 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
Governed tool access	Strict schemas, workspace containment, risk classes, one-shot approvals, and exactly-once effect protection	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
Runtime security	Secret redaction, untrusted-content boundaries, path controls, transactional writes, verification, and rollback receipts	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
Engineering operations	Source intelligence, repository triage, reproduction, multi-file patching, tests, review, and exact-state rollback	Move from issue report to reproduced failure, verified patch, and evidence-linked handoff in one continuous workflow
Cross-functional operations	Structured extraction, document and data workflows, browser and web tools, request-for-input, and external tool delegation	Coordinate finance, support, sales, IT, compliance, and back-office work while keeping human input available for decisions that require it
Continuous capability improvement	Authenticated self-correction, verified persistent improvement, isolated learning state, and rollback generations	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.

Profile	Best fit
Nexum-Lite/	Tool-calling-first agents, structured function execution, and responsive local operation
Nexum-Universal/	Balanced agents for tool use, repository work, research, and operational workflows
Nexum-Expanded/	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.

Repository Layout

Nexum/
|-- Nexum-Lite/
|   |-- model/
|   |-- runtime/
|   `-- notes/
|-- Nexum-Universal/
|   |-- model/
|   |-- runtime/
|   `-- notes/
|-- Nexum-Expanded/
|   |-- model/
|   |-- runtime/
|   `-- notes/
|-- assets/
|   |-- nexum-logo.svg
|   `-- nexum-hero.svg
|-- containers/
|   |-- Dockerfile
|   |-- compose.yaml
|   |-- docker-bake.hcl
|   `-- build-images.sh
|-- LICENSE
|-- NOTICE
`-- release_family.json

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 auth login
hf download namenotfoundai/Nexum --repo-type model --local-dir ./Nexum
cd Nexum

To pull only one independently loadable profile:

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:

python3 -m venv .venv
. .venv/bin/activate
python -m pip install ./Nexum-Universal/runtime

nexum bundle validate --model ./Nexum-Universal/model --deep
nexum doctor --model ./Nexum-Universal/model

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:

nexum chat \
  --model ./Nexum-Universal/model \
  --device cuda:0 \
  --prompt "Summarize the current directory."

nexum agent \
  --model ./Nexum-Universal/model \
  --device cuda:0 \
  --workspace ./workspace \
  --tools \
  --prompt "Inspect this project, run its tests, and report verified failures."

Useful discovery and operations commands include:

nexum tools list
nexum capabilities
nexum language-packs --query python
nexum templates list
nexum tasks list --workspace ./workspace
nexum events --workspace ./workspace
nexum status self-correction
nexum 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:

export NEXUM_API_KEY="replace-with-a-long-random-value"
export NEXUM_STATE_DIR="$PWD/nexum-state"

nexum serve \
  --model ./Nexum-Universal/model \
  --device cuda:0 \
  --workspace ./workspace \
  --state-dir "$NEXUM_STATE_DIR" \
  --state-namespace my-project \
  --host 0.0.0.0 \
  --port 8080 \
  --enable-tools

The primary HTTP surfaces are:

• 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:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Authorization: Bearer $NEXUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Nexum-Universal",
    "messages": [{"role": "user", "content": "Inspect the workspace and summarize its current state."}],
    "temperature": 0
  }'

NNF X example:

curl http://127.0.0.1:8080/agent/run \
  -H "Authorization: Bearer $NEXUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Inspect the repository, run the relevant checks, and return the verified result.",
    "workspace": "/workspace",
    "session_id": "project-a"
  }'

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.

Image	Contents
namenotfoundai/nexum-lite:0.1.0rc73	Complete Nexum-Lite profile
namenotfoundai/nexum-universal:0.1.0rc73	Complete Nexum-Universal profile
namenotfoundai/nexum-expanded:0.1.0rc73	Complete Nexum-Expanded profile
namenotfoundai/nexum-family:0.1.0rc73	All three profiles, selected with NEXUM_PROFILE

Build all four locally from the repository root:

./containers/build-images.sh docker

Create registry-neutral OCI archives instead:

NEXUM_IMAGE_OUTPUT_DIR=/mnt/attempt6/nexum-images \
  ./containers/build-images.sh oci

Run one embedded profile:

docker run --rm --gpus all --shm-size 16g \
  -p 8080:8080 \
  -e NEXUM_API_KEY="replace-with-a-long-random-value" \
  -v "$PWD/workspace:/workspace" \
  -v nexum-universal-state:/var/lib/nexum \
  namenotfoundai/nexum-universal:0.1.0rc73

Run the family image with a selected profile:

docker run --rm --gpus all --shm-size 16g \
  -p 8080:8080 \
  -e NEXUM_API_KEY="replace-with-a-long-random-value" \
  -e NEXUM_PROFILE=Nexum-Expanded \
  -v "$PWD/workspace:/workspace" \
  -v nexum-family-state:/var/lib/nexum \
  namenotfoundai/nexum-family:0.1.0rc73

Compose profiles are also available. Start only one service on a host port at a time:

NEXUM_API_KEY="replace-with-a-long-random-value" \
  docker 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

See NOTICE for a copy-ready notice.

Credits

NoNE was invented by Wendell Adams. Nexum is released by NameNotFound.ai.

Citation

@misc{namenotfound_nexum_2026,
  title        = {Nexum: A NoNE Model Family for Tool-Directed Work},
  author       = {Adams, Wendell},
  year         = {2026},
  organization = {NameNotFound.ai},
  note         = {Nexum-Lite, Nexum-Universal, and Nexum-Expanded}
}

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.

1. Download And Install

python3 -m pip install --upgrade huggingface_hub
hf auth login
hf download namenotfoundai/Nexum --repo-type model --local-dir ./Nexum
cd Nexum

export NEXUM_PROFILE=Nexum-Universal
python3 -m venv .venv
. .venv/bin/activate
python -m pip install "./${NEXUM_PROFILE}/runtime"

nexum bundle validate --model "./${NEXUM_PROFILE}/model" --deep
nexum doctor --model "./${NEXUM_PROFILE}/model"

2. Run The CLI

Use chat when you want a direct model response:

nexum chat \
  --model "./${NEXUM_PROFILE}/model" \
  --device cuda:0 \
  --prompt "Review this deployment plan and identify the highest-risk gap."

3. Run The NNF X Harness

Use agent when Nexum should inspect the workspace and drive its own tools:

mkdir -p workspace

nexum agent \
  --model "./${NEXUM_PROFILE}/model" \
  --device cuda:0 \
  --workspace "$PWD/workspace" \
  --session-id project-a \
  --tools \
  --prompt "Inspect this project, run the relevant checks, repair verified failures, and report the result."

4. Run With Docker

Build one self-contained profile image from the repository, then launch its authenticated tool-enabled service:

docker build \
  --file containers/Dockerfile \
  --target nexum-lite \
  --tag nexum-lite:local \
  .

mkdir -p workspace
export NEXUM_API_KEY="$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"

docker run --rm --gpus all --shm-size 16g \
  --publish 8080:8080 \
  --env NEXUM_API_KEY="$NEXUM_API_KEY" \
  --volume "$PWD/workspace:/workspace" \
  --volume nexum-lite-state:/var/lib/nexum \
  nexum-lite:local

5. Run The HTTP Server

Launch the installed runtime directly when you want OpenAI-compatible, agent-harness, MCP, A2A, and tool-execution endpoints:

mkdir -p workspace nexum-state
export NEXUM_API_KEY="$(python3 -c 'import secrets; print(secrets.token_urlsafe(32))')"
export NEXUM_STATE_DIR="$PWD/nexum-state"

nexum serve \
  --model "./${NEXUM_PROFILE}/model" \
  --device cuda:0 \
  --workspace "$PWD/workspace" \
  --state-dir "$NEXUM_STATE_DIR" \
  --state-namespace project-a \
  --host 0.0.0.0 \
  --port 8080 \
  --enable-tools

In another shell, send a completion:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Authorization: Bearer $NEXUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Nexum-Universal",
  "messages": [{"role": "user", "content": "Inspect the available capabilities and propose the next verified action."}],
  "temperature": 0
}'

Full-Scale And Evolving Editions

Want the strongest production version?

Contact ai@namenotfound.ai for Full Nexum with 1 Billion Window and access to private evolving architecture releases.

Full-scale access provides:

• the full-context release branch (for teams needing the 1B-token configuration),
• extended authority bundles that include evolving architecture modules (EAM-style),
• private profile options beyond Lite/Universal/Expanded for demanding tool-driven workflows,
• dedicated connector, security, and deployment templates for in-house integration,
• Expanded self-correction/self-improvement operating guidance and durable receipt workflows,
• evolving support for reproduction, triage, disclosure, patching, and agentic adaptation behaviors,
• architecture change notes plus controlled migration support.