Unified event streams: one timeline for humans and agents
AI-assisted research. This note was prepared with the assistance of AI tools. It may contain errors and is not professional advice. See our Legal Disclosures.
Marketing teams now run work through a mix of people, automations, and agents, and each of them writes its history somewhere different. That was tolerable when people did most of the acting. It stops being tolerable once agents send, spend, and route on their own, because the questions that matter after the fact cut across all of those systems at once.
In most marketing organizations, a single account's history is split across tools. Email sends live in the marketing automation platform, sales activity in the CRM, ad changes in each ad platform, and agent actions in whatever logs the agent runtime keeps. When someone asks what happened with an account last Tuesday, they rebuild the answer by hand. They work from several exports, each with its own clock and its own way of naming the same contact.
A unified event stream records significant actions, from people and agents alike, in one consistent, append-only timeline. In our research, we treat it as the shared memory of an agent program: the place where intent, action, and outcome line up.
Why fragmentation gets worse with agents
Human activity has natural friction. A marketer who changes a budget usually mentions it in a channel or a standup, so the context travels even when the logs do not. Agents leave no such trail unless you build one. They act faster, more often, and across more systems, and the reasoning behind each action lives in a run trace that the sales team will never open.
The cost shows up first as a coordination problem. Consider a hypothetical account. A lifecycle agent sends a renewal nudge on Monday, a sales rep sends a personal note on Tuesday, and an ABM agent launches a display sequence on Wednesday. Each actor checked its own system and saw nothing recent.
The customer saw three touches in three days from a company that seemed not to know itself.
What goes into the stream
An event is a small, immutable record of something that happened. We recommend that each one carry the same core fields, whatever system emitted it:
- Event type: a name from a shared vocabulary, such as
email.scheduled,budget.changed,lead.routed, orbrief.created. - Timestamps: when the action took effect, in UTC, plus when the event was recorded.
- Actor: a person, a specific agent and version, or a named automation, with an explicit actor type.
- Subject: the account, contact, campaign, or asset the action affected, using canonical identifiers.
- Cause: a reference to the plan, request, rule, or upstream event that triggered it.
- Links: pointers to the run trace, approval record, or asset involved.
Two of those fields do most of the work. Actor type lets you filter and compare human and agent behavior without guessing from usernames. Cause turns a flat log into a graph, so you can follow a chain from a plan to the brief it produced to the sends that brief scheduled.
Keep payloads small. The stream should say that a budget changed from one value to another and point to where the details live. It should not copy whole emails or customer records into each event, for reasons of both cost and privacy.
What it makes possible
Once the core fields are consistent, several uses come from the same data. Each one is hard to build from fragmented logs and close to trivial from a shared stream.
Account timelines. A sales rep can see each marketing touch for an account, human and agent, in one ordered view before a call.
Pre-action checks. Agents can query the stream before acting. A contact-frequency rule, such as one outbound touch per contact in a rolling window across all channels, becomes enforceable because all channels write to the same place.
Incident investigation. When a send goes wrong, the full sequence is available, including which agent version acted and which approval it relied on. This complements the run-level detail described in observability for marketing agents.
Measurement. Outcomes can be joined to the actions that preceded them, which is the raw material for attribution in an agentic funnel.
Audit. Legal, brand, and finance questions can be answered from one source instead of through a reconciliation project. See audit trails that satisfy legal, brand, and finance.
Design decisions that matter
The hardest parts of an event stream are agreements between teams. Storage and transport are comparatively easy. These are the decisions we would settle first:
- Agree on event types: a small shared vocabulary beats many inconsistent ones, so start with a short list and add types through review.
- Use canonical identifiers: accounts, contacts, campaigns, and agents need one ID each across systems, or the timeline fragments again at query time.
- Make writes idempotent: give each event a unique ID so a producer that retries does not create duplicates in the timeline.
- Record both clocks: store effective time and recorded time, because late-arriving events are normal and ordering by arrival will mislead you.
- Version the schema: treat event fields as a contract that producers and consumers depend on, with changes reviewed like code.
- Respect privacy: apply role-based access and retention rules suited to the data, and confirm specifics with counsel where personal data is involved.
Late events deserve a note. An ad platform may report a change well after it happened, and an agent run may flush its events only when it finishes. Consumers that decide from the stream, such as a frequency check, should read by effective time and allow a short settling window. They should not assume the latest event they can see is the latest one that occurred.
A rollout that stays small
You do not need the whole organization in the stream on day one. A staged rollout keeps scope honest and gives you something useful early.
- Pick the five event types with the highest consequence: messages sent, budgets changed, leads routed, approvals given, and content published.
- Instrument agents first, since you control their code and can emit events at the tool layer.
- Add the systems of record that hold human actions, starting with the CRM and the email platform.
- Build one consumer that people use, usually the account timeline, and let their feedback shape the vocabulary.
- Add pre-action checks only once coverage for the relevant channels is complete.
The last step is the one we would guard most carefully. An agent that checks the stream and finds nothing will act. If a channel is missing from the stream, "nothing" means "unknown", and the check has made things worse by appearing to work.
What to measure
Three measures tell you whether the stream is trustworthy enough to act on. Coverage is the share of high-consequence actions that appear in the stream, which you can estimate by sampling actions in each source system and looking them up. Latency is the gap between effective time and recorded time, by source. Conformance is the share of events that pass schema validation with canonical identifiers resolved.
We suggest reviewing all three weekly while the stream is new. Treat a drop in coverage for any source as an incident, not a data quality ticket, because downstream checks silently depend on it.
Where it fits
The event stream connects the data layer and the hub in our signal data flow diagram. Planning reads from it, agents check it before acting, and measurement joins outcomes to it afterward.
The open question we are studying is how much reasoning belongs in the stream. Recording that an agent acted is straightforward. Recording a compact, queryable account of why, without copying a full trace into each event, is harder, and we expect it to be where the most useful design work happens next.
How to apply this: choose the five event types that matter most and record them from each source, human and agent, in one place with the same core fields. Hold off on pre-action checks until coverage for those channels is complete.
Related research
Load, latency, and rate limits: scaling agents for traffic spikes
Agents that run smoothly in normal weeks can stall when volume spikes. Planning for load, latency, and rate limits keeps them running when it matters.
Retrieval for marketing agents: getting the right facts at the right time
Retrieval lets an agent look up what it needs instead of holding it all in its instructions. Done well, it raises accuracy and makes claims checkable.
The marketing data contract: schemas agents can depend on
When upstream data changes without warning, agents break quietly. A data contract defines what agents can rely on and who is responsible for keeping it true.
Put this research to work
Marketix turns these patterns into software: agents, automated workflows, and a hub that keeps people in control. Sign up for early access.
