1. AgilEntity is the commercial name of a distributed web application framework built on java technology by Apriority LLC. The framework utilizes the concept of entities to map business objects in a software class hierarchy. The entities are objects that have specific functionality within the framework structure. Entities are the business types for use in client code developed to use them which are also managed by the framework. Client code can be other java classes or objects or various script (jsp) and template technologies. Applications are built by combining the unique attributes of different entities to solve client problems efficiently.

    The framework has many important features that ensure applications can be securely built, deployed and managed.
    [Installing a New Cluster] Watch Tutorial!

  1. Designed around security: Unlike many web development platforms where security is an afterthought, security is a lynch pin of the design and in fact led to subsequent efficiencies that reduced required code significantly. In many commercial and open source platforms which are really nothing more than a hodgepodge of different technologies, the security issues (sometimes involving multiple logins to different management systems) vary depending on which point in the framework code one happens to be looking at. The AgilEntity framework is different, its multi-tenant architecture was designed from the start to use a permission based security system that interrogates Users for every action request that could effect more than one User on the system. This allows a User to be given full "God" rights on the system by granting of only 16 permissions, Users with no permissions granted have only the basic ability to login , view their settings and logout. Each Site or User account can be given further restrictions on login using Turing images through Live Verification which generates a randomly generated graphic challenge after login to ensure automated bots can not log into accounts. The UI (also managed by AgilEntity) dynamically controls what Users can view or access when they are logged in. If a User lacks the permission to do something, that User can't do it. The permission system is temporally sensitive using Flags (a formal Entity type in the framework) Users can be given authorized login time and date ranges. In fact, entire User authentication histories can be created by specifying the desired Flags and then delaying those actions for execution at run time while Users attempt to ingress and egress the system. This feature is trivial to employ without writing any code.
    [Create New Site] Watch Tutorial!
    [Branding a New Site] Watch Tutorial!
  2. Distributed by design: Any web application must be designed to scale, with mission critical enterprise applications moving from stand alone installs to web accessible versions, being able to guarantee that a site can stand to sudden increases in resource demand is critical to business success and growth. AgilEntity was designed so that each installed node of the application server can perform all of the functions of any other node and can handle requests to and from data from the database or file system and as well automatically load balance requests between nodes using the Lazy Request Routing algorithm. Dynamic load redistribution across installed nodes allows spikes in requests to fan out across all active nodes ensuring no single node is hammered. The distribution is geographic in scale and is not restricted to a single site of nodes. It is possible for multiple Branches to be established, these are node sets that intelligently distribute resource requests using the LRR, between node siblings when possible and can redirect requests to entirely different Branches if the local Branch is saturated with requests. Thus scalability can span continents and efficiently handle resource requests as they spike and grow to global scale.
    Watch Tutorial!
  3. System Configuration Monitoring: The ability to redistribute load dynamically is controllable by Users, Nodes can have specific values set on when they will accept or redirect requests individually. This allows the resource hit on each node to be tailored to the specifics of the hardware resources available on each Node guaranteeing that a mixed set of hardware does not suffer asynchronous load penalty under high load conditions. Designated Users can subscribe to be notified of Log events such as excessive database connections, failure to contact sibling nodes or warnings of pending resource saturation. Users can specify if a saturated Node should have its connections reset or if it should automatically allocate new resources to create more connections. Nodes can be deactivated from service, this allows the node to gradually deflate the existing User connections while redirecting requests for new connections to other Nodes so that eventual administrative actions can be taken on the Node. The entire cluster also has a plethora of features that can be adjusted or changed, from the format used across all Nodes for date and time, to specifying the path for loading dynamic classes to manage extensability.
    [Configuration Management Part 1] Watch Tutorial!
    [Configuration Management Part 2] Watch Tutorial!
  4. Action Oriented Workflow: Development these days is done on multiple developer workstations, sometimes using different development software depending on the taste or irreverence of the developer. The lack of standardization gives rise to problems in synchronizing code across the environment and development team. Workflow for tasks that the team is engaged in must happen outside of the development process in the form of dedicated workflow management tools for the development process itself. Thus IDE's, version control systems and the deployment and live environments are not part of a single workflow paradigm. In AgilEntity all this changes thanks to action oriented workflow, which is exactly what it sounds like. A piece of code (or any other Entity type) developed by a User can be reviewed by delegated peers prior to being submitted for inclusion in the live site. The code can be sent back and forth between the developer and the delegates and simultaneously notification of changes can be subscribed to by other developers. There is no complex process to set this up, it simply involves creating a workflow, defining the delegates for each action stage and then assigning it to a User or Users...it then just works for all Entities that the Users perform actions over implicitly. AOW was great but explicit construction of workflows required manual addition of users and performed random selection, what if the system could learn to watch execution of actions over time and predictively route work between agents? That is what the Action Delta Assessment (ADA) algorithm does, it calculates action deltas which are then used to make a prediction about the best agent for future requests for completion of action against a given type...over time this generalized algorithm learns who the best agent is for arbitrary executions of action, this and other new feature additions to the paradigm will be detailed in the white paper.
    [AOW Part 1] Watch Tutorial!
    [AOW Part 2] Watch Tutorial!
  5. Deep Versioning: Another huge problem with standard web development lies in the necessity of version control to ensure that multiple developers are using the latest version of code. This is usually done by synchronizing code at the end of the work day through a check out/check in process..but as many developers know , sometimes new code goes days without being checked in, this could lead to production issues when code that should be checked in is not in place to enable a desired production action. AgilEntity has deep versioning of all instances of any Entity type automatically, every action request to an instance spawns a version which can itself be reviewed , deleted or resubmitted by Users with the appropriate permissions. New code can be submitted to a workflow, which triggers notification of delegated agents to either review or execute the change via update or publish. Simultaneous teams can review changes to the same object using different versions and the results submitted to a common workflow for submitting to a designated manager. Since actions on instances can be monitored, all the people who should know about an event can know about that event the moment it occurs. This virtually eliminates the chance of code changes to an instance failing to be submitted for update or publish if those changes are critical to other production deployed code.
    Watch Tutorial!
  6. Entity LifeCycles: The deep versioning of changes to entity instances is tied to notification of events via the use of object LifeCycles. Every entity instance can have every action performed on or to it since its creation managed via an xml file. This file indicates any change as well as who requested or performed it, or both if the requestor is different from the performer (through workflow delegation). Users can subscribe to the life cycles of any instance they have View permissions to that have LifeCycles active, this allows the actions to those objects to notify those Users on action request via email. There is no use to have a critical action on an entity instance go unnoticed by managers or directors, Users can subscribe to the instances they wish and receive email notification of any action requests to those instances at any time.
    Watch Tutorial!
  7. XML at the core: XML is a core language element of the web for transmitting data and representation and rendering UI elements. It has made inroads into the enterprise in the form of web services and Service Oriented Architectures that use XML grammars to mediate software actions across disparate systems. AgilEntity was designed with the importance of XML from the start, all the management Entities have implicit XML representations that allow them to be imported, exported, transformed in any way desired by internal applications or external ones. A compositional hierarchy between various components of the framework simplify important tasks, for example dynamic load distribution between nodes employs the use of XML based files for storing the Branch and Node relationships. The relationships are also stored in the database but file system persistence also enables bootstrapping of clusters to desired needs. Every new Entity developed for run time inclusion is required to have an implemented XML representation that is used to manage transformation and publishing of instances of that Entity type. The implicit inclusion of custom XML representations for every Entity type also greatly reduces the amount of code that must be invoked to transform objects to desired rendered content forms, this is because generic DOM based extraction methods that use class introspection to determine object attributes and then return an XML description for objects require that the entire object and all its fields and methods be introspected even if only a few lines are to be transformed, this can be a very inefficient task especially if the initial request is only for several fields in the original object which is often the case. The use of minimal XML representations in AgilEntity ensures efficient object creation and transformation, translating to faster code, more users and applications per node and lower operating costs. The XML representation of the current viewed version of any Entity instance can be viewed or extracted by Users with the requisite permissions.
    Watch Tutorial!
  8. JSON at the core: Where XML is too cumbersome JSON serves as a light weight object and data language composed of formal javascript. It allows RESTful mediation that enables the vastly scalable service oriented architectures of high growth web applications. All Entity objects have JSON representations that can be used to transmit state to front end UI code using RESTful mediation. Enabling a faster development process by ensuring a stronger separation of concerns between the front end and the back end of any application.
  9. Extensibility: Distributed web applications must allow for the deployment of new compiled code into the system, as new applications are developed they should be able to be included for access by remote Users in as minimally intrusive a way as possible. AgilEntity allows new Entity tables to be added to the system database from the UI without the need for dedicated database vendor client tools. New classes coded to the Entity and DBEntity API's deployed in the form of JAR archives can be dynamically accessed to enable the new tables and extend the API using the UI. The vendor DB specific syntax can be provided to build efficient table schemas for the new types, as with all Entity actions adding new Entities can be submitted to Workflows, Delegated to agents and is subject to Deep Versioning and LifeCycle monitoring. The framework actually manages itself during deployment of new Entity types or applications built on those types.
    Watch Tutorial!
  10. Self/Recursive/Fractal management: One of the main problems with most frameworks is that they don't manage their own content, AgilEntity was designed to manage itself in a recursive manner. All of the frameworks user interface templates and resources are actually managed on the framework using the AOW paradigm and thus benefit from all the innovations of that new paradigm as described above.
  11. Immutable architecture: AgilEntity is an inherently immutable architecture, because all templates are managed as part of AOW all changes are deep versioned and delayed actions (see DAD below) always point to a valid unique version of the object state at the time it was requested. This allows a fine grained ability to roll back object state to any point in its life cycle for any object managed on the system. Immutability also exists in the AOW paradigm, the ADA algorithm creates temporal immutability by storing a history of performance of actions and uses this to make predictions for implicitly work routing any delegated work actions to the best available person regardless of location. This creates a brand new set of possibilities for workflow management systems that were not realizable before AOW/ADA.
  12. DAD: The Delayed Actions Daemon is an independent thread that can be enabled on every Node, it is responsible for performing actions on objects delegated for execution by Users at a later date. Essentially a distributed message queue processor, DAD utilizes system Flags associated with delayed actions to temporally manage the execution of actions against Entity objects. Any action on any Entity object instance can be delayed for performance by DAD at a specific time or specific date or combinations of dates and times indicated by the Flag. For example, DAD can schedule changes to Node attributes such as how they will redirect incoming requests depending on what time of the day it is (if hits tend to peak then) or during date ranges every month. User objects can have their permissions changed so that on the weekends they are weaker than during the week day. Changes to UI templates can be triggered for publishing to the web context on a given launch date and time. Any modifications to any object can be Flagged for execution by DAD. Actions can be made to recur periodically, be made to span only a certain set of days of every month or a specific month or be made to only be invoked during the weekdays or weekends or specific week days at any desired time. DAD operates across all Entity actions (view[implicit],update,create,publish,delete,import,export and search[NA]) which includes applications built on the base framework or added in later via extensibility, no coding is needed to enable this, all new Entities implicitly can have actions against them executed by DAD. Since DAD can run on every Node a multi-node cluser properly designed, has no single point of failure for delegated action execution requests. Since DAD is just another action performing agent, albeit an automated one, all its action executions on objects are captured by the LifeCycle's of those objects. Allowing recurring DAD tasks on objects to notify subscribed Users.
    [DAD Part 1] Watch Tutorial!
    [DAD Part 2] Watch Tutorial!
  13. Context Browsing: The context browser allows Users to view the files on the system established web contexts, which specify the IP address, security, port and visibility of files managed through the framework. The default contexts enable a non ssl secure local port and an ssl secure remote port for remote authentication to the system. Users with the requisite permissions can view, upload or delete files on the context.
    [Web Context Management] Watch Tutorial!
  14. DB Vendor Agnostic: The framework is db vendor neutral, all database code is polymorphic and invokes the correct vendor at run time based on the vendor selected at install time. The framework can be extended to support new db vendors at install time! The framework currently has implemented support for Microsoft Sql Server 7 or better and MySql Server 5 or better but additional vendors with more vendors coming soon.


  1. Enterprise Content Manager:The first application built on the AgilEntity framework is a content management system unlike any other. Implicitly taking advantage of the previous features it adds the ability to create and manage Sites with their own contexts for deploying of content created and managed on the system. Articles in the form of Story instances can be published to Groups which are composed into Pages which can be published to static files or the rendered content of those Pages called dynamically through an associated Page JSP template. Each Site can be given a set of Delivery locations and the content can be delivered using any of a set of existing Protocols (Local File, Ftp, Sftp or Smtp) using any desired file type (xml, html, jsp, txt, pdf, doc..etc.) New protocols and FileTypes can be added at runtime. Content can be consumed from external sources, transformed and rendered for internal or external delivery. This content can come in the form of inbound FTP or via URL. Consuming of external content is subject to delayed execution via DAD allowing automated feed generation from external sources. The CMS allows dynamic variation of code for display in pages based on the parent Category or Page, allowing Pages to be dynamically restyled for outbound rendering all without requiring a single line of code be written. New Contexts loaded for the Sites created on the CMS can be managed via the Context Browser by designated Users from any location. New Users can be created and associated with new Sites providing efficient segmentation. This multi-tenant architecture enables independent branding for each Site management interface.
  2. Collaboration Module: The second application built on the AgilEntity framework is a revolutionary real time collaboration concept. It ties the security features provided by the framework to the delivery and notification capabilities of the CMS to provide each User with their own real time collaboration space. Users can invite other Users into the space, eject Users, share files and establish real time tracking of events like file share, ingress/egress and category shift that occur in the conversation. Users can send Instant Messages, send offline messages, send out TimeLine Events and even include attachments with their Events. Designated Users can generate code for inviting guests to serve as customer service agent, this allows a Site to enable customer service on Sites managed and created using the CMS. The tool also enables interacting Users to collaborate on any change to the framework happening via AOW in real time allowing ready communication upon reception of action event notifications to various entity object instances. Editors, Writers and Content producers of the CMS can collaborate on pending changes, share drafts and e-communicate from the same interface that they actually do their work in. Finally the collaboration has built in multi-language translation support via the Translation on Agent Demand (TOAD) algorithm, a scalable algorithm for enabling real time translation between users speaking different languages. The integration of collaboration into the workspace brings new efficiencies to performance of any action done on any other application.

    The Future:

  1. The AgilEntity framework is a new web based platform for allowing a woven code, content and collaboration experience unlike anything possible previously. Each application added to the framework implicitly takes advantage of the frameworks features and can readily incorporate the features of previously added applications. The self management of the system allows everything from logos to the design and actual execution of the UI code to be changed or updated by Users given specific permissions to do so. Additional applications will be added to tailor to specific vertical industries, these will naturally take advantage of the features of previous applications. As more applications are added the efficiency of the overall framework improves as the code required to do incredibly complex things goes down over time. For example, human resource management is already implicit in the framework and can be realized by simply specifying User Permissions appropriately (for creating or managing User objects and nothing else), Apriority LLC will heed the advice of its customers and will be rolling out new applications to address demand.