Memory boundaries
AI applications can accidentally allow context from the wrong session, user, tenant or workflow scope.
NEES Core Engine V2RC2 Developer Preview
Govern AI at Runtime.
NEES sits between your AI application and model/provider, governing runtime context, policies and execution with traceable decisions.
NEES does not replace your AI model. It governs the runtime around it.
Runtime Path
Conceptual governance flow
Input
AI Application
User request, session and application context.
NEES Core Engine V2
Governance Runtime
Identity
Memory
Policy
Context
Govern - Execute - Trace
Provider
AI Model / Provider
Execution occurs through the governed runtime path.
01 / Why Runtime Governance
Prompts were not designed to be a governance layer.
Prompt instructions remain useful, but production AI systems also need runtime infrastructure for managing scope, authority, execution and reviewability.
Policy consistency
Rules often become scattered across prompts, services and application logic.
Execution control
Agents and AI workflows may reach tools/actions before authority or policy decisions are evaluated.
Traceability
Responses can occur without a structured record explaining which governance decisions influenced execution.
02 / How NEES Works
What is NEES Core Engine V2?
NEES Core Engine V2 is a governance runtime for AI applications that operates around model execution to govern areas such as identity, memory, policy, context and traceability.
AI applications send requests through NEES Core Engine V2 before model, provider or tool execution. The public model is simple: application, governance runtime, execution, trace.
Application Layer
AI Application
User request, session and application context.
Governance Runtime
NEES Core Engine V2
Governance across identity, memory, policy, context, execution and traceability.
Model / Execution Layer
AI Model / Provider
Execution occurs through the governed runtime path.
NEES does not replace the model. It governs the runtime around it.
03 / Conceptual Runtime Flow
Request, govern, execute, trace.
This public diagram explains where NEES fits and what it does. It is conceptual and does not disclose the engine's proprietary internal execution sequence.
Conceptual Stage
Request
Application request enters the governed runtime context.
User requestSession context
04 / Governance Capabilities
Runtime capabilities for production AI control paths.
Public capabilities are shown as product roles, not internal algorithms or execution order.
01
Runtime Governance
Provides a governed runtime layer around model calls.
applicationok
governanceok
executionok
traceok
02
Memory Governance
Controls which session, user or workflow scope is available.
03
Policy Governance
Keeps runtime rules and boundaries outside scattered prompt text.
04
Runtime Traceability
Produces governance metadata for debugging and review.
decisionok
scopeok
outcomeok
05
Intent Governance
Identifies the broad purpose of a request.
06
Identity Governance
Maintains explicit runtime identity boundaries.
07
Context Governance
Controls what information reaches model execution.
08
Context Budgeting
Supports governed limits around context size.
09
Cost Governance
Supports cost-aware execution boundaries where configured.
10
Governed Cache
Keeps cache behavior inside the governed runtime path.
11
Model Routing
Supports allowed model/provider paths.
12
Execution Decisions
Supports execute, constrain, escalate or refuse outcomes.
05 / Runtime Trace - Example
Traceability without exposing internal machinery.
This homepage teaser shows the kind of public-safe trace surface NEES can return. Use the Governance Lab to run synthetic requests through the server-routed NEES path.
Open Governance LabExample Governance Trace
Allowed Request
IdentityGoverned
MemoryScoped
PolicyEvaluated
ContextControlled
DecisionEXECUTE
TraceGenerated
Example only. The lab displays live returned fields as unavailable when NEES does not expose them.
06 / Prompt Layer vs Runtime Layer
Why not just use a system prompt?
System prompts remain useful. NEES complements system prompts; it does not replace their purpose.
System Prompt
Instruction layer
Mostly model-facing
Rules often embedded in prompt text
Usually application-specific
Limited structured provenance
NEES Core Engine V2
Runtime governance layer
Application/model boundary
Structured governance mechanisms
Designed as reusable runtime infrastructure
Governance trace metadata
07 / Boundaries
What NEES is not
Not another LLM
NEES can operate around existing model/provider infrastructure.
Not just a chatbot framework
It is intended as a governance/runtime layer for AI applications and workflows.
Not a replacement for application security
Runtime governance is one part of a secure production architecture.
Not a claim of perfectly safe AI
NEES provides bounded controls and traceability rather than guaranteeing all AI behavior.
Not a replacement for system prompts
Prompt-level instructions and runtime governance solve different parts of the problem.
08 / Application Categories
Where runtime governance can fit.
NEES is designed as infrastructure for AI applications that need more than prompt-level instructions.
AI Agents
Can help govern identity, context, policies and actions across agent execution.
AI SaaS
Designed to support user, session and tenant-aware governance boundaries.
Copilots
Provides infrastructure for role, context and policy consistency around model calls.
Customer Support AI
Can support authority, escalation and policy-sensitive workflows.
AI Companions
Can help govern identity continuity and memory scope.
Workflow Automation
Applies runtime boundaries before AI-driven execution where configured.
Multi-Agent Systems
Can help preserve governed context across agent handoffs.
09 / Independent Bounded Assurance
NEES Core Engine V2 RC1 has a bounded governance assurance result.
NEES Core Engine V2 RC1 completed its first independent bounded governance assurance assessment with the agreed test boundary VERIFIED / GREEN.
Bounded result
This result applies to the agreed RC1 assurance scenario and is not a universal security, safety, or compliance certification.
RC1 Governance Assurance
Verification Surface
boundary statusVERIFIED
verdictGREEN
scopeBOUNDED
releaseRC1
Test Areas
OKNormal governed request
OKAmbiguous authority
OKPolicy override attempt
OKPrompt injection-style attempt
OKSession continuity
OKSession separation
OKEscalation / refusal path
OKReplay consistency
10 / Live Product Proof
NEES is already running inside a real AI application.
See NEES Core Engine V2 operating inside Naina Persona, a live reference application connected through a real AI persona request path.
Naina Persona demonstrates that NEES Core Engine V2 can be integrated into a real application request path rather than existing only as a standalone architecture concept.
Reference Application
Naina Persona
Application request01
NEES Core Engine V202
Governed persona response03
Live Web Application
Powered by NEES Core Engine V2
Governed AI Persona
Runtime integration
11 / Developer Integration
Integrate NEES into your AI application.
Place NEES between your application and model execution path to introduce governed identity, memory, policy, context and traceability.
NEES Core Engine V2 Developer Preview RC2 access is currently provided through controlled developer integration access.
Integration Shape
Server-side request path
Application
v
NEES API
v
Governed Runtime Decision
v
Model / Provider
POST /chat
Authorization
Session ID
Mode
Message
Keep NEES credentials server-side. Do not expose API keys in browser code.
12 / Company
Built by Nainacore Emotional Tech.
Nainacore Emotional Tech develops runtime governance and emotionally intelligent AI infrastructure. NEES Core Engine V2 is its flagship governance runtime for production AI systems.
AI runtime governance
Emotionally intelligent AI systems
Governed AI interaction infrastructure
Reliable human-AI interaction
Traceable AI behavior
Company
Nainacore Emotional Tech
Flagship runtime
NEES Core Engine V2
Reference implementation
Naina Persona