The Essence Agent – The brains of the Essence Platform
Essence is a New Architecture for Computing
Unlike operating systems that are separate from middle-ware and applications, every software product based on Essence has Agents, Powers, Skills, and Media packaged together as a unified Essence package.
Legacy Software Platforms (Operating Systems and their core applications), and the various files required to operate, are measured in gigabytes.
Whether running as a virtual machine (Essence VM), as an appliance (e.g., Essence for Ubuntu) or without an operating system (Essence Noir), Essence is a fraction of the size of legacy platforms. This is possible because the code that Essence needs to operate is quite small.
Agent Core Powers vs. Platform Powers
Essence has been designed to deliver the optimal experience. A major design consideration was to separate what is needed at boot up (Agent Core Powers) from what is subsequently used to operate where there is fixed code (Platform Powers). There many advantages to this approach. Here are just a few:
- Fast Boot Up – Essence Aptivs have ~1msec boot up time. This is possible because the Agent and its core powers are ~28kb in size.
- Higher Security – The Agent is encrypted with multiple encryption algorithms and uses a complex obfuscation scheme as it generates machine instructions. It also runtime checks packages of fixed code and data to prevent malicious attacks.
- Modularity – Any packaged fixed code (e.g., APIs, drivers, emulators, AI algorithms, browser engines, databases, etc.) only gets loaded into memory on-demand. This delivers both interoperability and portability with efficiency levels that are well suited for the demands of a rapidly growing IoT and IoE global IT environment.
Size comparison of mainstream operating systems and version of Essence
Transcending Operating Systems
Essence is not an operating system. It is a new approach to regenerating machine instructions, integrating them with written code and data based upon pre-loaded developer and user expressed wants.
While Essence is like a unikernel, its runtime regeneration of machine instructions to maximize speed or space or wattage, and its per-info-unit security allows it to apply a new approach to computing.
For example, Essence for macOS, Linux, and Windows boots up from a ~128 kilobyte Agent package in approximately 1 millisecond. The Agent processes any required fixed code (as Powers). Then it regenerates millions or billions (whatever is needed) of lines of machine instructions for operating, in real-time. The regenerative instructions are deleted after they are used, often within milliseconds of being created. Packages of fixed code are hot swapped in/out of memory on demand, which has the added benefits of efficient resource utilization and greater security (e.g., reducing the attack profile for fixed code).
The amount of fixed code required vs. generated instructions is determined by the user, conditions (changing machine workload, energy, and operating modes) and changes in the data source used.
Two Primary Ways of Deploying Essence
- Essence automatically generates, adapts, and/or optimizes computer-readable machine instructions for parallel processing in response to its evaluation of memory latency, number of data fetches, number of instruction cycles, order of instructions in the instruction pipeline, size of the cache, wattage consumed by each series of instructions, and the modes of the underlying chip and instruction set architecture chosen.
- The Essence Platform allows packages of solutions to be created and deployed as virtual machines or native applications (both compliant with a host operating system) or hardware-direct (no operating system needed) instantiations.
More Than 11-years in the Making
Essence is the result of an 11-year project that took a fresh look at computing with the goal of creating a more human-centered, reliable, secure, efficient (space and energy), and high-performing approach to computing. This required rethinking and innovative approaches to operating systems, management of system files and data, and the tools needed for improving the software development process.
Several prototypes and released software products have been created using Essence. However, additional platform tools are needed to make Essence ready for use by the software developer community. These are short duration projects that will enable us to deliver Essence and the evolution of software to WantWare that it makes possible. Our own internal developers are creating apps in minutes or hours without writing any code.
What is an Essence Agent?
Wantverses
Origin is the starting wantverse filled with foundational ideas and abilities for all platforms. It includes all the foundation Ideas, Records, Actions, and SpaceTimes for interfacing between human and machine.
A specific wantverse with as many device specific capabilities exposed as possible.
An individual users’ wantverse of the style/design/terms/etc. and personal wants on a particular machine, not everywhere.
A wantverse storing the users’ past events.
Agent Core Powers
Agent Core Powers are 8 packages of ‘hard-coded’ instructions that utilize a knowledge-database and supporting data that has been trained and tuned for the specific platform, its generic and unique features, and all the caveats that must be observed to optimally regenerate machine instructions, and to run and evaluate fixed code on the fly.
Operating System(OS) specific process-launching/thread-spawning or Hardware UEFI/BIOS specific or both for startup process (~1 msec start)
Handles initial processor/bus/memory assessment and resource pooling.
Identity Confirmation and Location Probing (find current user, their last Essence session, along with style, rules, and history)
Manages a variety of verifications, guards, and runtime trust-checks. Only handles the other 7 Powers and itself but does so natively at startup.
Matches streams of Essence Elements into foundation segments of hardware-machine code or emulation code for 1 or more boot-time chips such as CPUs, Bus-controllers, DSPs, Media-Codecs, & other chips available at startup or uniquely configured (SoC).
Handles connecting a series of ‘Code-Maker’ results with other Powers from other Wantverses based on the platform’s prior runs and training/history data with ranges of scored (good/neutral/bad) results.
Manages issuing, assessing, and balancing various results of the Power04:Code-Maker running across the currently available chip.
Manages all shutdown or unrecoverable error states, blackbox logging, & cleanup issues specific to the Platform.
The Essence Powers System
The EPS has 64 Powers Categories organized into 8 Families each with 8 Powers Subsystems that cover all possible ways that an Essence Agent can process native source code for any device, service, computing platform (e.g. AI algorithms, drivers, APIs, emulators, browser engines, virtual machines, operating systems, media types, network code, databases, etc.), all inputs and outputs. Powers are a way to make source code composable (mix and combine machine behaviors), like Lego Bricks. The Agent combines Powers with its own regenerative machine instructions to create customizable, adaptable, and highly-scalable experiences, in real-time.
Learn details about each of the Powers Subsystems summarized below here.
Machine Instructions Regeneration and Acceleration
The Essence Agent, present in every application/Aptiv, allows us to combine and remix existing AI algorithms (e.g., TensorFlow, Caffe, etc.), other code written by engineers, with Agent generated auto-tuning, auto-scaling and auto-synching algorithms all on the fly. The result is an AI Superset (combination of many AI algorithms executed at the same time).
The Agent provides higher levels of parallel execution than any other solution to date. This enables computing systems to do more with less compute resources and data samples. When the task is bigger, simply add more hardware and the Agent dynamically adapts.
Test have been performed across many architectures. Tests via a 2011 Mac Pro resulted in reduction in processing time from 32 minutes (serialized) to 18.8 seconds (parallelized) and 103X speedup of the task.
Eliminating serial code and detecting other limiting factors (e.g., I/O bottlenecks) at runtime makes the key difference.
Products in Development
Learn more
