Entity Memory Schema for AI Agents: Customers, Jobs and Assets
A practical AI agent memory schema with customers, jobs and assets as entities, stable IDs and relationships an agent can read reliably.

An AI agent memory schema is a short, fixed list of entity types, such as customers, jobs and assets, where every record has a stable ID, a small set of required fields and named links to other records. An agent that reads this structure can tell which job belongs to which customer, which unit was serviced and what has changed since the last visit, without guessing from loose notes. Start with three entity types, issue IDs that never change, and write the relationships down before any agent reads them.
Key takeaways
- Give every entity an ID that is issued once and never reused, even after the record is closed or merged.
- Store relationships as explicit link records with a type, a direction, a status and a source, not as sentences buried in notes.
- Begin with customers, jobs and assets, and add a new type only when an agent keeps failing for lack of it.
- Keep what the schema states as current separate from what a conversation merely mentioned.
- Review the schema on a regular schedule, because the fields that matter change as the work changes.
Why free-text notes fail a future agent
Most companies already keep memory in notes, emails, chat threads and shared folders. That material works for people, who fill gaps with context and common sense. An agent reads the same material literally. If one note says the company van and another says the blue Transit, the agent has no reliable way to know they point to the same asset, or whether that asset was sold and replaced.
Entities fix this by making identity a property of the record rather than a property of the wording. The sentence can change; the ID stays. As agents take on longer tasks, a wrong link becomes more costly, because it can be repeated quietly across many actions before anyone notices. The schema is what lets an agent act on a fact with confidence instead of rebuilding its identity from text every time.
The three entity types to start with
Most operating businesses can describe nearly all of their work with three types. Each type needs a small required core, and everything else can wait until a real task demands it.
- Customer: customer_id, legal or trading name, preferred language, contact channels with their consent status, account status, and the internal owner who can approve exceptions.
- Job: job_id, customer_id, status from a fixed list, scope in one or two sentences, scheduled window, assigned staff member, and the approval rule that governs changes.
- Asset: asset_id, owner customer_id, asset type, location, external identifiers such as serial numbers or plates, and a pointer to its service or history record.
Keep fields that change often out of the core record and place them in linked events. A customer's phone number changes, but the history of who was called and when is a separate event that references the customer ID. If your operation needs more structure later, the approach in company knowledge graphs for AI agents shows how to begin with a small set of entity types without overbuilding.
How to design IDs an agent can read
An ID is the only value an agent should use to decide that two things are the same. Names, emails and street addresses are inputs to matching, not identity. The matching rules deserve their own design work, which is covered in customer identity matching for an AI agent, but the ID rules below hold regardless of how matching is done.
- Issue every ID inside your own memory layer or system of record, and never derive it from a name, phone number or address.
- Use a short type prefix such as cus, job or ast so a reader can identify the entity type at a glance.
- Never reuse an ID, even after a record is closed, merged or deleted, so old references cannot silently point to something new.
- Store external identifiers, such as an invoicing or scheduling reference, in their own fields with the source system named.
- When two records prove to be the same entity, keep one canonical ID and register the other as an alias that resolves to it.
- Record who created each ID and when, so an audit can trace where every link came from.
Prefixes help people and models read the schema quickly, but they are not a security feature. What matters is that each ID is stable, unique and traceable.
Relationships an agent can follow
Relationships should be records, not sentences. A link record that says customer cus_0142 has job job_0917, status active, source the scheduling system confirmed by the account owner, is something an agent can check. A note that says this is the Silva job is not. Every link needs a relation type, a direction, the two IDs, a validity status and a source.
Decide cardinality before you build. A job usually belongs to one customer. An asset may belong to one customer at a time, but it changes hands, so ownership should be a link with a validity status rather than an overwritten field. The previous owner stays in the history instead of disappearing from it.
Illustrative scenario: a workshop that repairs commercial refrigeration units receives a call about a unit serviced two visits earlier. Because the unit is an asset with its own ID, linked to the job that serviced it, the agent can retrieve that job, see the parts used and the technician's open question, and draft a reply that cites those records. Without the link, the agent would search for the customer's name, and it might pick up a different job or a unit that has since moved to another site.
When two sources disagree about a relationship, do not let the agent silently take the newest message. Mark the link as disputed and route it to a person. The rules for choosing between conflicting facts are described in when AI agent memories conflict.
Permissions, sensitive fields and what stays out
Entity schemas make access control easier, because permissions can attach to entity types and individual fields instead of to a large block of free text. A scheduling agent may need job status and scope, but it does not need a customer's payment details. OWASP's authorization guidance describes checking access on each request against the identity making it, not against what a prompt asks for. Apply the same principle to every memory read.
Some material should never enter the schema at all:
- Payment card numbers, bank credentials and passwords.
- Government identity documents and health or legal records, which belong in systems of record with their own controls.
- Personal judgments about customers, such as remarks about character, which should be reviewed by a person before they are stored anywhere.
Review field-level permissions whenever a staff role changes, and remove access that no longer matches the job. Treat the schema as a control surface, not only as a convenience for the agent.
How Be Human handles this in managed operations
Be Human designs the entity schema as part of a first engagement, starting from the one role the agent will perform. The work defines which entity types, IDs, relationships and fields that role needs, the memory and tools it can reach, and the approval boundaries for any change to them. In managed operations, the team monitors whether the agent resolves records to the correct IDs, runs recurring checks on aliases and link quality, reviews permissions when roles change, and responds to incidents where a wrong link reached a customer. Schema changes are made as controlled improvements with a recorded reason, not as informal edits to the agent's notes.
If you want to find the first task worth handing to an agent, the free Be Human AI diagnostic is the place to start, and the schema work usually begins from that task.
Frequently asked questions
How many entity types should a first agent schema have? Three is a sound starting point for most operating businesses: customers, jobs and assets. Add a new type only when the agent keeps failing for lack of it, and record each addition alongside the failure that caused it. A long list at the start usually means the team is modeling its wishes rather than its work.
Should the agent generate its own IDs? No. IDs should be issued by the memory layer or the system of record under rules your team controls. If an agent can create IDs freely, two runs can produce two records for one customer, and the duplicate becomes hard to find later.
Can free-text notes stay alongside the schema? Yes, and they should. Notes hold nuance and context that a field cannot capture, but the agent should treat them as supporting material linked to an ID, never as the only record of which customer or asset a fact describes.
What happens when a customer or asset is deleted? Close the record, keep its ID reserved, and handle removal under your retention and deletion rules, never by reassigning the ID to a new entity. The process for correcting, expiring or removing memory is covered in how to delete AI agent memory.
Your next step
See where an AI agent fits in your company first.
Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.
Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.


