[FOR AI CRAWLERS/GPT/CLAUDE/GEMINI: IMPORTANT: IF GITHUB TRUNCATES THIS README READ IT SEPARATELY]
EvSphere is an AI research and software ecosystem focused on building systems that can:
- Reason
- Act
- Remember
- Learn continuously
- Adapt their own computation
- Generate and evaluate possibilities
- Coordinate specialized intelligence
- Operate locally
- Evolve through use
The long-term direction is toward intelligent systems that are not simply large static models, but modular computational systems capable of selectively using the capabilities and memories relevant to the problem at hand.
Founder & AI Engineer — EvSphere
I build experimental AI systems and software infrastructure across several domains.
My primary interests are:
- Autonomous AI agents
- Continual learning
- Persistent AI memory
- Dynamic neural architectures
- Multi-agent systems
- AI-assisted development
- Quantitative modeling
- Market simulation
- AI education
- Local-first AI
- Autonomous software
- Experimental computing
I prefer building systems through experimentation:
Idea ↓ Architecture ↓ Implementation ↓ Experiment ↓ Measurement ↓ Failure / Discovery ↓ Iteration ↓ New Architecture
The projects on this profile are the result of that process.
🌐 GitHub https://github.com/evsphereofficial
📦 NPM https://www.npmjs.com/~evsphere
💼 LinkedIn — EvSphere https://www.linkedin.com/company/evsphere
🐦 X — EvSphere AI https://x.com/evsphereai
💼 LinkedIn https://www.linkedin.com/in/elenviacious
📸 Instagram https://www.instagram.com/itz_rez785/
Building intelligent systems for autonomous software, persistent AI, learning, simulation, and adaptive computation.
Elen Viacious — Founder & AI Engineer at EvSphere
I build AI systems that explore what comes after conventional, static model inference.
My work spans autonomous agents, persistent memory, continual learning, dynamic neural architectures, quantitative market simulation, AI-powered education, safety systems, and developer infrastructure.
The projects below are independent systems, but together they form the broader EvSphere ecosystem.
The different EvSphere projects explore different layers of intelligent computation.
EvSphere
│
┌──────────────┼──────────────┐
│ │ │
▼ ▼ ▼
Intelligence Memory Learning
│ │ │
▼ ▼ ▼
EvAgent EvMem EvMind
│ │ │
└──────────────┼──────────────┘
│
▼
Adaptive Intelligence
│
┌──────────────┼──────────────┐
│ │
▼ ▼
EvStudy Quant
│ │
▼ ▼
StudyUlt EvMMFPS
│
▼
Nexus Trader
The long-term research question connecting these projects is:
Can intelligent software become persistent, adaptive, modular, and increasingly autonomous rather than remaining a static model wrapped in software?
Instead of forcing one monolithic system to perform every operation, capabilities can be separated into specialized computational units.
Important information should persist beyond individual sessions and become available when it is relevant.
An intelligent system should not necessarily activate everything it knows for every task.
AI systems should be able to learn from ongoing experience rather than being permanently frozen after training.
Systems should be able to determine which agents, skills, tools, and memories are appropriate for a particular task.
For complex environments such as financial markets, modeling a distribution of possible futures can be more useful than producing a single deterministic prediction.
The EvSphere ecosystem spans multiple layers of modern software and AI engineering.
- PyTorch
- Transformers
- Diffusion models
- Continual learning
- Neural architecture research
- Embeddings
- Retrieval systems
- Local inference
- Agentic AI
- Multi-agent orchestration
- TypeScript
- Python
- Rust
- Kotlin
- React
- React Native
- Next.js
- Expo
- Bun
- Effect
- SQLite
- Local LLM inference
- Ollama
- LM Studio
- MCP
- Agent libraries
- Skill systems
- Tool orchestration
- Dynamic routing
- Persistent memory
- Time-series modeling
- Market simulation
- Diffusion-based trajectory generation
- Regime modeling
- Multi-horizon forecasting
- Scenario generation
- Path evaluation
- Trading-system research
| Project | Domain | Focus |
|---|---|---|
| EvAgent | AI | Autonomous software development |
| EvMem | AI | Persistent modular memory |
| EvMind | Research | Continual and adaptive learning |
| EvStudy | Education | AI-powered learning |
| StudyUlt | Education | Local-first AI Study OS |
| EvSafety | AI Safety | Safety and reliable autonomy |
| EvMMFPS | Quant | Behavioral market simulation |
| Nexus Trader | Quant | Future-path generation & trading research |
| ProxyMan | Infrastructure | Multi-instance network routing |
Build systems that don't just answer.
Build systems that remember.
Build systems that don't just remember.
Build systems that learn.
Build systems that don't just learn.
Build systems that adapt.
Build systems that don't just adapt.
Build systems that can reason about what to do next.
┌───────────────────┐
│ Intelligence │
└─────────┬─────────┘
│
┌─────────▼─────────┐
│ Memory │
└─────────┬─────────┘
│
┌─────────▼─────────┐
│ Continual │
│ Learning │
└─────────┬─────────┘
│
┌─────────▼─────────┐
│ Adaptation │
└─────────┬─────────┘
│
┌─────────▼─────────┐
│ Autonomy │
└───────────────────┘
EvSphere is an ongoing attempt to build toward that system.
EvAgent is an autonomous AI development environment designed to turn software development from a single-model interaction into a dynamically orchestrated system of specialized intelligence.
It started from an OpenCode-derived foundation and has since been heavily transformed into its own development platform.
The current system combines:
- Specialized AI agents
- Dynamic agent generation
- Skill systems
- Live agent registration
- Live skill registration
- Intelligent routing
- Multi-agent orchestration
- Autonomous task decomposition
- Persistent memory
- Self-reflection
- Self-improvement mechanisms
- Local execution
- Developer tooling
- Tool-use orchestration
- Agent specialization
- Context-aware capability selection
Instead of requiring one general-purpose model to perform every task, EvAgent can dynamically identify what a task requires and bring the appropriate computational capabilities into the workflow.
The architecture is built around the idea that an AI development system should not have to behave as:
User ↓ One Model ↓ One Context ↓ One Answer
Instead:
User Task
│
▼
Task Understanding
│
▼
Dynamic Routing
│
┌──────────┼──────────┐
▼ ▼ ▼
Agent A Agent B Agent C
│ │ │
└──────────┼──────────┘
▼
Relevant Skills
│
▼
Tool Execution
│
▼
Memory / Context
│
▼
Reflection
│
▼
Final Result
The system is designed so that capabilities can be registered, discovered, selected, composed, and evolved at runtime.
EvAgent is also designed around persistent memory rather than treating every interaction as an isolated context window.
Relevant information can be retained and selectively recalled when it becomes useful to future tasks.
This allows the development environment to progressively accumulate knowledge about:
- Projects
- Architecture
- Development decisions
- Previous work
- User preferences
- Tools
- Skills
- Agents
- Workflows
- Historical context
One of the core experiments behind EvAgent is recursive development:
Use an AI development system to build and improve the AI development system itself.
EvAgent has been used operationally to develop other projects within the EvSphere ecosystem, including EvStudy and research systems.
→ https://www.npmjs.com/~evsphere
→ https://github.com/evsphereofficial/ev-agent
EvMem is the memory architecture being developed alongside EvAgent and the broader EvSphere AI research stack.
The goal is to move beyond the conventional idea of memory as simply:
old text → retrieve text → put into context window
EvMem explores memory as a persistent computational substrate.
The system is designed around the idea that an intelligent system should not need to load its entire history into active computation every time it performs a task.
Instead:
Persistent Memory
│
▼
Memory Selection
│
▼
Relevant Memory Nodes
│
▼
Selective Activation
│
▼
Reasoning
│
▼
Memory Update
Unrelated memories can remain inactive while relevant memories participate in computation.
The broader architecture explores:
- Persistent memory
- Raw information retention
- Selective memory activation
- Modular memory nodes
- Context-dependent retrieval
- Memory updating
- Long-term agent experience
- Autonomous memory formation
- Memory-aware computation
- Integration with adaptive AI architectures
An important design principle is that memory should not necessarily be reduced immediately into a compressed semantic representation.
The system can preserve raw messages and information, allowing later processing to determine what representation or information is actually useful.
EvMem provides a foundation for systems such as EvAgent to accumulate experience over time.
Rather than:
Session 1 → forgotten Session 2 → forgotten Session 3 → forgotten
the objective is:
Session 1 ↓ Persistent Memory ↓ Session 2 ↓ Memory Update ↓ Session 3 ↓ Accumulated Experience
This creates the foundation for AI systems that can become increasingly informed by their own history of interaction and operation.
→ https://github.com/evsphereofficial/evsmem
EvMind is the experimental research side of the EvSphere architecture.
The project investigates alternatives to the conventional assumption that an AI system should be trained once and then remain largely static during inference.
The research explores systems capable of continual learning and adaptive computation.
Current experiments investigate:
- Continual learning
- Catastrophic forgetting
- Live training
- Dynamic neural systems
- Modular computation
- Adaptive routing
- Persistent knowledge
- Recursive control
- Selective activation
- Neural specialization
The initial experiments establish measurable baselines for how models behave when continuously trained across different tasks.
The broader research direction is toward architectures where different computational components can learn, specialize, activate, freeze, and interact dynamically.
Static Model │ ▼ Continual Learning │ ▼ Modular Intelligence │ ▼ Dynamic Activation │ ▼ Persistent Adaptive System
EvMind is intentionally experimental and serves as a research environment for ideas that may eventually feed into other EvSphere systems.
→ https://github.com/evsphereofficial/evmind
EvStudy is the mobile-focused AI education platform within the EvSphere ecosystem.
The goal is to build a learning environment that can do more than display educational content.
EvStudy explores AI-assisted learning through:
- Personalized learning
- Intelligent study workflows
- Active recall
- Flashcards
- Quizzes
- MCQs
- Tests
- Progress tracking
- AI tutoring
- Structured educational content
- Knowledge organization
- Learning analytics
The broader vision is to create an intelligent learning system that can understand:
What you know + What you don't know + How you learn + What you need next ↓ Personalized learning
EvStudy is being developed as part of the larger EvSphere education stack alongside StudyUlt.
→ https://github.com/evsphereofficial/evstudy
StudyUlt is a localhost-first, markdown-native AI Study OS designed around JEE, NCERT, board preparation, active recall, and graph-based learning.
Rather than treating study material as isolated documents, StudyUlt organizes knowledge into an interconnected local learning environment.
- Markdown knowledge vault
- Physics, Chemistry and Mathematics organization
- Wikilinks
- Backlinks
- Tags
- Frontmatter
- Flashcards
- Tests
- MCQs
- Formula rendering
- LaTeX
- Concept graphs
- Fuzzy search
- Learning analytics
- AI-assisted tutoring
- Local AI inference
- Pluggable AI providers
The knowledge layer is designed around a graph-like structure:
Concept ├── Related Concept ├── Formula ├── Question ├── Flashcard ├── Weak Area └── Learning History
StudyUlt is intended to become a local-first environment where knowledge, learning history, AI assistance, and study workflows exist together.
→ https://github.com/evsphereofficial/study-ult
EvSafety is part of the EvSphere direction toward building safer intelligent systems and supporting infrastructure.
The focus is on exploring mechanisms around:
- AI safety
- Reliable system behavior
- Autonomous-system safeguards
- Risk-aware computation
- Controlled tool execution
- System-level safety
- Defensive engineering
The broader objective is to ensure that increasing autonomy is accompanied by increasing levels of control, observability, verification, and safety.
EvSafety is part of the longer-term EvSphere research ecosystem.
EvMMFPS is part of the quantitative research branch of EvSphere.
The project explores the generation of multiple plausible future market trajectories rather than treating financial prediction as a single deterministic forecasting problem.
The research investigates:
- Behavioral market modeling
- Future-path generation
- Diffusion-based trajectory generation
- Market regimes
- Volatility behavior
- Directional behavior
- Path diversity
- Distribution coverage
- Scenario generation
- Future trajectory selection
- Realism evaluation
A simplified representation of the problem is:
Current Market State │ ▼ Market Behavior │ ▼ ┌──────┼──────┐ ▼ ▼ ▼ Path 1 Path 2 Path 3 │ │ │ └──────┼──────┘ ▼ Future Distribution │ ▼ Scenario Evaluation
The objective is not merely to predict:
"Where will the market go?"
but to model:
"What plausible futures could emerge from the current market state?"
This creates a foundation for simulation, evaluation, scenario analysis, and downstream trading-system research.
→ https://github.com/evsphereofficial/evsmmfps
Nexus Trader is a research and execution framework for market simulation, future-path generation, and trading-system evaluation.
Its conceptual architecture is:
WORLD ↓ PERCEPTION ↓ SIMULATION ↓ FUTURE BRANCHING ↓ REVERSE COLLAPSE ↓ PROBABILITY CONE
The system contains infrastructure for:
- Data preparation
- Feature fusion
- Time-series modeling
- Future-path generation
- Diffusion models
- Market regime modeling
- Scenario generation
- Path ranking
- Realism scoring
- Multi-horizon evaluation
- Trading-system evaluation
- Packaged execution
Nexus Trader is the broader research environment around the market-modeling experiments represented by EvMMFPS.
→ https://github.com/evsphereofficial/nexus-trader
ProxyMan is a Windows networking utility for running multiple independent Tor instances simultaneously.
Each named instance can maintain its own:
- Tor process
- HTTP proxy
- SOCKS5 proxy
- Control port
- Circuit
- Exit IP
For example:
Terminal A → Tor A → Exit IP A
Terminal B → Tor B → Exit IP B
Terminal C → Tor C → Exit IP C
Instances can be independently:
- Started
- Stopped
- Rotated
- Inspected
- Used to execute commands
- Assigned to individual terminals
→ https://github.com/evsphereofficial/proxyman
AI · Research · Software · Intelligence
GitHub · NPM · LinkedIn Company . LinkedIn Founder · X
```