Entities: AI agents with temporal memory and self-management

[THIS REPO HAS SINCE BEEN BROUGHT INTERNAL, SO WILL NOT BE MAINTAINED]

Here, I introduce the concept of an AI entity. An entity is an agent that not just manages it's own workflow, but also it's run-schedule.

This project now uses an API client to interact with the backend services. The API client is configured using environment variables:

• API_BASE_URL: The base URL of the API (defaults to 'http://localhost:8000')

You can set these in a .env file at the root of the project.

Entities should be able to communicate through multiple channels like phone, SMS, email, etc.

A persistent entity can manage a long term relationship with the user or multiple users - not just a single session or interaction. An entity needs to be able to manage an individual conversation, have some memory of conversational history but also their history with the user.

After a few messages back and forth to an entity, those message will be stored in the entity's short-term memory, like this:

The short-term memory stores the exact OpenAI messages objects so the conversation can be resumed at will, regardless of which channel the message was sent through.

For long-term memory, we introduce a concept called enshrining. Enshrining a memory store is basically just having an LLM summarize the messages in the memory store.

For our example above, the enshrined version would look like this:

John Doe initiated a conversation via SMS with a simple greeting. The exchange was brief and casual, primarily serving as a check-in. There are no significant details or topics discussed worth noting beyond the friendly interaction. The conversation reflects a willingness to engage and maintain communication.

We can then add this to the long-term memory store, and clear the short-term memory.

Notice how the data type of the long-term memory is a string, not an object.

This experience mimics how humans remember things - we remember short-term things very well, but the long-term memory has less resolution.

You could continue adding more memory layers, like an "ultra-long-term memory" that is a summary of the long-term memory, and so on.

Entities do not just run when you are interacting with them, they are capable of running autonomously. Entities can do things in the background without you asking them to. They also sleep when they have nothing to do. When an entity falls asleep, it's short-term memory is automatically enshrined into long-term memory.

Adapters are how you give you entity access to other systems. For example, you could add an adapter that allows the entity to send and receive SMS messages.

To build an SMS adapter, you'd need to create tools that let the entity read and send SMS messages, then bundle them into the adapter. Give that adapter to the entity and voila, they can send and receive SMS messages. When the entity wakes up, it will probably try and read new SMS messages to see if there are any new conversations to respond to.

Adapters like this can also be totally hidden - you might want to give you entity access to a todo list tool that the user never needs to know about. Just make the adapter, expose the tools, and add it to the entity.

Check index.ts for an example of how to use the entity with the CLI.

• Add email adapter.
• Add phone adapter.
• Allow adapters to forcibly wake the entity, like getting a phone call.
• Build a proper testing suite, probably with another LLM as the tester.