# RevCent AI Memos Overview This document explains AI Memos in RevCent: what they are, how they are created, why they exist, how AI Assistants use them, how they can trigger downstream automation, and how ecommerce businesses can use them as an operational alerting and workflow mechanism. This is a broad overview, not an MCP operation-specific guide. Sources: - RevCent Knowledge Base: AI Assistants / AI Memos — `https://kb.revcent.com/en/tools/ai/assistants#ai-memos` - RevCent operation schema for `GetAIMemo` - RevCent operations list showing AI Assistant and AI Memo operation availability - RevCent AI Assistant overview — `https://revcent.com/documentation/markdown/mcp/operation/OverviewAIAssistant.md` --- # What Are AI Memos? AI Memos are RevCent alerts or internal notification records created by AI Assistants. An AI Memo is meant to capture an important AI-detected issue, recommendation, warning, summary, or operational finding that a human or automation should pay attention to. Examples: ```text Gateway decline rate appears abnormal. Customer threatened a chargeback. Refund volume is unusually high. Failed subscription renewals increased today. High-value customer needs immediate retention follow-up. Fraud pattern detected across recent sales. Shipment issue appears unresolved after multiple contacts. ``` AI Memos help turn an AI Assistant's analysis into a durable RevCent item that can be viewed, tracked, and used to trigger further automation. --- # AI Memos Are Created by AI Assistants AI Memos are created by AI Assistants. Important: ```text AI Memos are not normal user-created notes. AI Memos are not manually created with a standard CreateAIMemo API operation. AI Memos are created by AI Assistants during an AI Thread when the assistant is instructed to create one. ``` The current RevCent operation set includes: ```text GetAIMemo ``` for retrieving an existing AI Memo. It does not expose a normal direct `CreateAIMemo` operation to MCP/API clients. This means MCP/AI should understand the creation path as: ```text AI Assistant is triggered ↓ AI Thread runs ↓ Thread Step instructs AI to create an AI Memo when appropriate ↓ AI Assistant creates the AI Memo ↓ AI Memo appears in RevCent and can create downstream event automation ``` If an MCP client wants an AI Memo created, it should usually trigger or configure an AI Assistant whose Thread Builder flow is explicitly designed to create one. Do not treat AI Memos as arbitrary notes that MCP/API can directly create. --- # AI Memo vs AI Assistant vs AI Thread These concepts are related but different. | Concept | Meaning | |---|---| | AI Assistant | The configured automation: trigger, instructions, tools, Thread Builder flow, limits, and actions. | | AI Thread | One run/execution of an AI Assistant. | | AI Memo | A memo/alert created by an AI Assistant during an AI Thread. | Conceptual flow: ```text AI Assistant = automation definition. AI Thread = one execution of that automation. AI Memo = important finding created by the assistant during the thread. ``` A single AI Assistant can create many AI Threads over time. A single AI Thread may create an AI Memo if the workflow instructs the assistant to do so and the assistant determines an AI Memo is appropriate. --- # Purpose of AI Memos AI Memos are meant for important internal alerts and AI-detected findings. They are useful when the AI identifies something that should not just stay buried inside an AI Thread. Good AI Memo purposes: ```text Alert staff to urgent business risk. Summarize an important AI finding. Notify humans of abnormal patterns. Create a durable internal alert. Trigger downstream workflows from an AI-detected condition. Make AI analysis visible to users/admins. ``` AI Memos are especially useful when the AI finds a condition that needs human review or broader automation. Examples: ```text AI detects a likely chargeback threat from a customer note. AI detects gateway outage risk based on failed transactions. AI detects a high-value subscription renewal failure. AI detects suspicious fraud pattern. AI detects fulfillment issue affecting multiple customers. AI detects refund volume spike. AI detects a VIP customer needs escalation. ``` --- # What AI Memos Are Not For AI Memos should not be used for every small AI action. Avoid creating AI Memos for: ```text Routine successful actions. Every assistant run. Every customer message. Every minor analysis result. Internal reasoning traces. Long transcripts. Low-value noise. Normal expected business activity. Information that should be a normal Note. Information that should be structured Metadata. Information that should simply be an Email Template or Function output. ``` AI Memos should be reserved for meaningful alerts, findings, or escalations. If every AI Assistant thread creates an AI Memo, the memo system becomes noisy and less useful. --- # AI Memo Detail Fields The `GetAIMemo` operation retrieves the details of one AI Memo. Important fields include: | Field | Meaning | |---|---| | `id` | 20-character AI Memo ID. | | `created_date_unix` | When the AI Memo was created. | | `updated_date_unix` | When the AI Memo was last updated. | | `subject` | AI Memo subject/title. | | `message` | AI Memo message/body. | | `ai_assistant` | AI Assistant that created the AI Memo. | | `ai_thread` | AI Thread in which the AI Memo was created. The `ai_thread` field can optionally be used with `GetAIThread` for deeper context. | | `status` | Current AI Memo status: `Unread` or `Read`. | Example conceptual response: ```json { "id": "XXXXXXXXXXXXXXXXXXXX", "subject": "Chargeback threat detected", "message": "Customer note indicates they may file a chargeback unless shipping issue is resolved.", "ai_assistant": { "id": "AAAAAAAAAAAAAAAAAAAA", "name": "Customer Note - Chargeback Threat Detection" }, "ai_thread": { "id": "TTTTTTTTTTTTTTTTTTTT" }, "status": "Unread" } ``` --- # AI Memo Status AI Memos have a status. Current known statuses: ```text Unread Read ``` This allows users to distinguish new/unreviewed AI-detected alerts from memos that have already been reviewed or processed. After a memo is successfully reviewed or processed, use `MarkAIMemoAsRead` to set it to `Read` and help prevent duplicate downstream actions. Use cases: ```text Support team reviews unread AI Memos each morning. Risk team watches unread chargeback/fraud memos. Operations team clears shipping/fulfillment memos after review. Finance team reviews refund-volume memos. ``` --- --- --- # Optional: Retrieve the Responsible AI Thread When reviewing an AI Memo, it may be beneficial to also retrieve the AI Thread that created the memo. `GetAIMemo` returns the AI Thread associated with the memo: ```text ai_thread.id ``` MCP/AI can optionally use that ID with: ```text GetAIThread ``` Example: ```json { "ai_thread_id": "XXXXXXXXXXXXXXXXXXXX" } ``` This is optional. It is not required for every memo review. However, retrieving the AI Thread can be useful when the memo subject/message is not enough context or when a workflow needs to understand how the AI Assistant reached the memo-worthy conclusion. --- ## Why Retrieve the AI Thread? The AI Thread can provide broader context about the run that created the AI Memo. `GetAIThread` can return information such as: ```text AI Thread status AI Thread messages Message count Total tokens consumed Total processing time Trigger source Account event notation, if event-triggered API call trigger details, if API-triggered Web user trigger details, if web-app triggered Associated AI Assistant Previous AI Thread handoff context, if applicable Third-party AI integration Timer/delay state ``` This can help answer questions such as: ```text What did the assistant analyze before creating the memo? Was the AI Thread triggered by an account event, API, or web app user? Which account event caused the AI Thread? Was this memo created as part of an assistant handoff? What messages or tool-call requests occurred in the thread? Did the AI Thread complete successfully or end in an error/timer state? How much AI processing did the thread consume? ``` --- ## When Retrieving the AI Thread Is Useful Retrieve the responsible AI Thread when: ```text The memo subject/message is too brief. The memo requires investigation before action. The memo triggered a high-impact workflow. The memo may cause customer contact, refunds, risk action, or payment changes. The memo appears incorrect or needs audit/debugging. The memo was created through assistant-to-assistant handoff. The memo relates to revenue, fraud, chargebacks, gateway health, or customer escalation. The downstream workflow needs to understand the trigger source or AI Thread messages. ``` Examples: ```text AI Memo says gateway decline spike detected → retrieve AI Thread to see analysis and trigger context. AI Memo says chargeback threat detected → retrieve AI Thread before escalating or contacting customer. AI Memo says VIP customer at risk → retrieve AI Thread before triggering retention workflow. AI Memo says fraud pattern detected → retrieve AI Thread before blocking, escalating, or triggering another assistant. ``` --- ## When Retrieving the AI Thread May Not Be Necessary Do not retrieve the AI Thread automatically in every workflow if the memo itself is enough. It may be unnecessary when: ```text The memo subject/message already has all needed context. The workflow only needs to route or notify. The memo is low-risk. The AI Thread messages are not needed. The goal is simply to mark a reviewed memo as read. ``` Retrieving the AI Thread adds extra API activity and may expose more context than needed. Use it intentionally. --- ## Recommended Review Workflow With Optional Thread Retrieval Basic workflow: ```text 1. GetAIMemo 2. Review subject, message, status, AI Assistant, and AI Thread ID 3. Process the memo 4. MarkAIMemoAsRead after successful processing ``` Enhanced workflow: ```text 1. GetAIMemo 2. Review subject, message, status, AI Assistant, and AI Thread ID 3. If more context is needed, call GetAIThread using ai_thread.id 4. Review AI Thread trigger, messages, status, handoff context, and processing details 5. Process the memo 6. MarkAIMemoAsRead after successful processing ``` Important: ```text GetAIThread should usually happen before MarkAIMemoAsRead when thread context is needed for processing. ``` Do not mark the memo read before reviewing the necessary memo/thread context. # Marking AI Memos As Read AI Memos can be marked as read using the `MarkAIMemoAsRead` operation. This is important because AI Memos may trigger downstream manual, AI, MCP, Function, or external workflows. After a memo has been reviewed or processed, it should usually be marked as read so the same memo is not repeatedly handled as if it were new. Operation: ```text MarkAIMemoAsRead ``` Required input: ```json { "ai_memo_id": "XXXXXXXXXXXXXXXXXXXX" } ``` Use `MarkAIMemoAsRead` after retrieving and processing the memo with: ```text GetAIMemo ``` Recommended workflow: ```text 1. AI Assistant creates AI Memo. 2. ai_memo.created event triggers a workflow. 3. Workflow retrieves the memo with GetAIMemo. 4. Workflow reviews the subject, message, AI Assistant, AI Thread, and status. 5. Optionally, workflow calls GetAIThread using the memo's ai_thread.id when deeper context is needed. 6. Workflow performs the needed action. 7. Workflow calls MarkAIMemoAsRead after successful processing. ``` --- ## Preventing Duplicate Operations on the Same Memo Marking an AI Memo as read helps prevent duplicate operations on the same memo. This is especially important when `ai_memo.created` triggers automation such as: ```text Functions Other AI Assistants Email Templates AI Voice Agents, when applicable External tools External AI agents Support or risk workflows ``` Without marking the memo as read after processing, downstream systems may accidentally process the same memo multiple times. Potential duplicate actions include: ```text Sending duplicate internal emails. Triggering the same AI Assistant repeatedly. Creating duplicate tickets. Calling the same customer more than once. Inserting duplicate metadata. Creating duplicate notes. Running the same Function workflow multiple times. ``` The correct pattern is: ```text Retrieve memo. Check memo status. Process memo if status is Unread. Mark memo as Read after successful processing. Avoid re-processing memos that are already Read unless the workflow explicitly requires it. ``` --- ## Manual, AI, and External Review `MarkAIMemoAsRead` is meant to keep track of which AI Memos have already been reviewed by: ```text Humans AI workflows External systems Functions MCP clients Operational automation ``` Examples: ```text A support manager reviews a chargeback-risk memo and marks it read. A Function sends a Slack alert for a gateway-risk memo and marks it read. An external ticketing system creates a ticket from the memo and marks it read. Another AI Assistant performs deeper analysis of the memo and marks it read. ``` --- ## MCP/AI Guidance for Marking Read MCP/AI should usually call `MarkAIMemoAsRead` only after the memo has actually been reviewed or processed. Do not mark a memo as read before processing it. Good: ```text GetAIMemo → review/process → MarkAIMemoAsRead ``` Bad: ```text MarkAIMemoAsRead → then attempt to process later ``` Before marking read, MCP/AI should confirm: ```text The memo was retrieved. The memo content was reviewed. The intended workflow action was completed or intentionally skipped. The memo no longer needs to appear as unread for other systems/users. ``` If processing fails, the workflow should generally leave the memo unread so it can be retried or reviewed manually. --- ## AI Memo Status Strategy AI Memo status should be treated as a processing/review signal. ```text Unread = memo needs review or processing. Read = memo has already been reviewed or processed. ``` This can be used by workflows to avoid duplicate work. Example: ```text If status = Unread: process memo mark as read If status = Read: do not process again unless explicitly instructed ``` This is similar to a lightweight queue-processing pattern. --- ## Updated Event-Driven Workflow Pattern A complete event-driven AI Memo workflow should include read-state handling. ```text AI Assistant creates AI Memo ↓ ai_memo.created event triggers Function ↓ Function calls GetAIMemo ↓ Function checks status ↓ Function processes memo only if Unread ↓ Function performs downstream action ↓ Function calls MarkAIMemoAsRead ``` This avoids duplicate downstream operations while preserving the memo as a durable internal alert. # AI Memos as Internal Alerts AI Memos are internal business alerts. They are not customer-facing messages by default. Use AI Memos when the assistant needs to alert the RevCent user/admin/team. Use Email Templates or other customer communication tools when the assistant needs to message the customer. Example: ```text AI Memo: "High refund volume detected today." Customer email: "We are sorry for the inconvenience. Here is your update..." ``` AI Memos are for internal visibility. --- # How AI Assistants Create AI Memos AI Assistants create AI Memos when their Thread Builder instructions tell them to do so. Example Thread Step instruction: ```text Review this customer's latest note and recent transaction history. If the customer appears to be threatening a chargeback, create an AI Memo with a clear subject and concise message explaining the risk. ``` Example AI Memo result: ```text Subject: Chargeback threat detected Message: Customer note says they will file a chargeback if shipping issue is not resolved. Review customer and shipment immediately. ``` Another example Thread Step: ```text Analyze failed transactions from the last hour. If one gateway appears to have an abnormal spike in declines, create an AI Memo summarizing the gateway, time range, and likely issue. ``` Example AI Memo result: ```text Subject: Possible gateway issue detected Message: Declines on Gateway A increased sharply in the last hour. Review gateway routing and payment profile rules. ``` --- # AI Memo Event Trigger: `ai_memo.created` When an AI Memo is created, it can produce an account event. Important event: ```text ai_memo.created ``` This event is powerful because it turns an AI-detected finding into a trigger for downstream automation. Conceptual flow: ```text AI Assistant detects important issue ↓ AI Assistant creates AI Memo ↓ RevCent emits ai_memo.created event ↓ Other RevCent automation can run ``` --- # Extending AI Memos With Automation An `ai_memo.created` event can be used to trigger follow-up workflows. Possible downstream automation includes: ```text Functions Other AI Assistants Email Templates AI Voice Agents, when configured for supported account-event workflows External tools or AI agents through Functions/API/webhook-style integrations ``` This makes AI Memos a bridge between AI reasoning and action. Examples: ```text AI Memo created for chargeback threat ↓ Function triggers Slack/Discord/internal alert ↓ Chargeback mitigation assistant runs ↓ Support email template sends update to customer ``` ```text AI Memo created for gateway outage risk ↓ Function checks gateway metrics ↓ AI Assistant creates deeper BigQuery analysis ↓ Admin notification email is sent ``` ```text AI Memo created for VIP customer risk ↓ Retention assistant is triggered ↓ AI Voice Agent calls customer if workflow rules allow ↓ Support team receives internal email ``` --- # Why AI Memo Events Matter AI Memos are useful by themselves as alerts, but their true value increases when they become automation triggers. Without events: ```text AI Assistant finds issue. Human must manually notice and act. ``` With `ai_memo.created`: ```text AI Assistant finds issue. AI Memo is created. Automation reacts immediately. Relevant team/tools/workflows are notified. ``` This makes AI Memos useful for high-priority ecommerce operations. --- # Ecommerce Use Cases ## Chargeback Threat Detection Trigger: ```text note.created ``` Assistant action: ```text Analyze customer note for chargeback threat. ``` If threat detected: ```text Create AI Memo. ``` Then `ai_memo.created` can trigger: ```text Risk team Function. Chargeback prevention assistant. Support email template. External case-management tool. ``` --- ## Gateway Failure Monitoring Trigger: ```text Schedule ``` Assistant action: ```text Run BigQuery analysis of recent declines and gateway performance. ``` If abnormal failure detected: ```text Create AI Memo. ``` Then `ai_memo.created` can trigger: ```text Function to notify admin. Another AI Assistant for deeper gateway analysis. Internal email to payments team. ``` --- ## Subscription Renewal Risk Trigger: ```text subscription_renewal.updated.failed ``` Assistant action: ```text Review failed renewal and customer value. ``` If high-value or urgent: ```text Create AI Memo. ``` Then `ai_memo.created` can trigger: ```text Retention workflow. Email Template. AI Voice Agent follow-up, if configured and appropriate. Function to tag customer or insert metadata. ``` --- ## Refund Volume Spike Trigger: ```text Schedule ``` Assistant action: ```text Analyze refund volume by campaign/product/day. ``` If spike detected: ```text Create AI Memo. ``` Then `ai_memo.created` can trigger: ```text Operations review Function. Refund risk assistant. Finance notification email. ``` --- ## Fulfillment Issue Detection Trigger: ```text shipping.updated ``` or: ```text Schedule ``` Assistant action: ```text Analyze shipping delays, failed delivery indicators, or repeated customer notes. ``` If issue detected: ```text Create AI Memo. ``` Then `ai_memo.created` can trigger: ```text Warehouse escalation Function. Customer service assistant. Internal operations email. ``` --- ## Fraud Pattern Detection Trigger: ```text fraud_detection.created ``` or schedule. Assistant action: ```text Analyze fraud details and related customer/order patterns. ``` If pattern is concerning: ```text Create AI Memo. ``` Then `ai_memo.created` can trigger: ```text Risk team alert. Fraud review assistant. Function to insert metadata or block customer group membership. ``` --- # AI Memos vs Notes AI Memos and Notes are different. | Feature | Best For | |---|---| | AI Memo | Internal AI-generated alert/finding/escalation created by an AI Assistant. | | Note | Short human-readable context attached to a specific item. | Example AI Memo: ```text Subject: Gateway decline spike detected Message: Declines increased sharply on Gateway A in the last hour. Review routing and gateway health. ``` Example Note: ```text Customer requested callback tomorrow afternoon. ``` Use AI Memos for important internal alerts. Use Notes for item-specific history/context. --- # AI Memos vs Metadata AI Memos and Metadata are different. | Feature | Best For | |---|---| | AI Memo | Alerting humans and triggering event-based workflows from AI findings. | | Metadata | Structured name/value data for search, reports, segmentation, and automation logic. | Example AI Memo: ```text Subject: High-value renewal risk Message: Customer has high LTV and failed renewal due to expired card. Prior notes show churn risk. ``` Example metadata: ```json { "name": "ai_retention_risk", "value": "high" } ``` Often, an assistant may use both: ```text AI Memo = alert humans. Metadata = structured reportable status. ``` --- # AI Memos vs Email Templates AI Memos are internal. Email Templates are customer/admin messages sent through SMTP workflows. Use AI Memo when: ```text The AI needs to alert internal users. ``` Use Email Template when: ```text A message should be sent to a customer, admin, or recipient. ``` An `ai_memo.created` event may trigger an Email Template if the business wants an email notification or follow-up communication. --- # AI Memos vs Functions AI Memos are alert records created by AI Assistants. Functions are custom JavaScript workflows. A Function may be triggered after an AI Memo is created. Example: ```text AI Assistant creates AI Memo for chargeback threat. ai_memo.created event triggers Function. Function sends alert to external tool and inserts metadata on customer. ``` This allows AI findings to become custom automation. --- # AI Memo Creation Best Practices ## 1. Create AI Memos Only for Meaningful Findings AI Memos should represent something important. Good: ```text Possible gateway outage detected. High-value customer at risk. Chargeback threat detected. Fraud pattern detected. Refund spike detected. ``` Bad: ```text Assistant completed normally. No issue found. Routine note summarized. Customer purchased product. ``` ## 2. Use Clear Subjects Good subject examples: ```text Chargeback threat detected Possible gateway issue High-value renewal failure Refund spike detected Fulfillment escalation needed ``` Poor subject examples: ```text Alert Memo Issue AI found something Review ``` ## 3. Keep Messages Concise and Actionable The memo message should explain: ```text What the AI found. Why it matters. What should happen next. What item/customer/campaign/gateway/timeframe is involved, if known. ``` Good: ```text Customer threatened chargeback in latest note after missing shipment. Review shipment and contact customer today. ``` Poor: ```text The assistant analyzed many things and had a long internal reasoning process. ``` ## 4. Avoid Internal AI Reasoning Do not put chain-of-thought, internal hidden reasoning, or unnecessary analysis traces in an AI Memo. Use final conclusions and actionable context. ## 5. Avoid Alert Fatigue Do not create too many AI Memos. If every routine event creates an AI Memo, users will start ignoring them. Use filters, careful trigger design, and clear Thread Builder conditions so memos are created only when meaningful. ## 6. Pair AI Memos With Metadata When Useful If the finding should also be searchable/reportable, insert structured metadata. Example: ```text AI Memo subject = Chargeback threat detected Metadata = ai_risk_finding: chargeback_threat ``` Metadata should be concise and not flooded. --- # Event-Driven Workflow Patterns ## Pattern 1: AI Memo → Function ```text AI Assistant creates AI Memo ↓ ai_memo.created triggers Function ↓ Function calls external system, inserts metadata, or notifies team ``` Use for: ```text Slack/Discord/internal alerting. CRM ticket creation. Risk escalation. Custom routing. External AI agent notification. ``` --- ## Pattern 2: AI Memo → Another AI Assistant ```text General AI Assistant creates AI Memo ↓ ai_memo.created triggers specialized AI Assistant ↓ Specialized assistant performs deeper analysis ``` Use for: ```text General risk detection → chargeback specialist. Gateway monitoring → payment routing specialist. Support issue detection → customer service specialist. Fraud alert → fraud review assistant. ``` --- ## Pattern 3: AI Memo → Email Template ```text AI Assistant creates AI Memo ↓ ai_memo.created triggers Email Template ↓ Internal admin/team receives notification ``` Use for: ```text Urgent internal email alerts. Support escalation notices. Finance/risk notifications. Operations summaries. ``` --- ## Pattern 4: AI Memo → Function → External AI Agent ```text AI Assistant creates AI Memo ↓ Function is triggered ↓ Function sends structured event to external AI agent/tool ↓ External agent performs follow-up task ``` Use for: ```text External ticket systems. External AI agents. Workflow orchestration tools. Custom dashboards. Notification platforms. ``` --- # AI Memo Retrieval Use: ```text GetAIMemo ``` to retrieve one specific AI Memo by ID. Input: ```json { "ai_memo_id": "XXXXXXXXXXXXXXXXXXXX" } ``` Use `GetAIMemo` when: ```text The AI Memo ID is known. The user wants the subject/message/status. The user wants to know which AI Assistant created the memo. The user wants to know which AI Thread created the memo. ``` After retrieving and processing a memo, use `MarkAIMemoAsRead` to update the memo status to `Read` and help prevent duplicate workflow processing. Current schema fields include: ```text id subject message ai_assistant ai_thread status created_date_unix updated_date_unix ``` --- # Searching and Reporting on AI Memos MCP/AI should not assume a direct AI Memo list operation exists unless the current operation list exposes one. The current operation list exposes: ```text GetAIMemo ``` for a single memo. For reporting, metrics, or broad analysis, MCP/AI should first inspect available BigQuery tables using: ```text GetBigQueryTables ``` If an AI Memo table or event/API-call representation is available, use `BigQueryRunQuery` with appropriate filters. If no direct AI Memo table exists in the current schema, reports may need to use related sources such as: ```text API calls created by AI Assistants. AI Assistant / AI Thread records. Notes or metadata created by memo workflows. Downstream `ai_memo.created` event-triggered actions. ``` Do not guess unavailable table names. --- # Recommended AI Memo Workflow Design A good AI Memo workflow usually looks like this: ```text 1. AI Assistant trigger is narrow and intentional. 2. Assistant analyzes relevant data. 3. Thread Branch determines whether memo-worthy condition exists. 4. Assistant creates AI Memo only if condition is meaningful. 5. AI Memo subject is clear. 6. AI Memo message is concise and actionable. 7. ai_memo.created event triggers appropriate follow-up automation. 8. Follow-up automation creates notes/metadata/emails/functions only when useful. ``` --- # MCP/AI Guidance When helping a user with AI Memos: 1. Explain that AI Memos are created by AI Assistants. 2. Do not claim MCP/API can directly create AI Memos unless a direct Create operation exists in the current operation list. 3. Use `GetAIMemo` to retrieve one known AI Memo. 4. Optionally use `GetAIThread` with the memo's `ai_thread.id` when the memo needs deeper context, audit, or workflow validation. 5. Use `MarkAIMemoAsRead` after successful review or processing to prevent duplicate operations on the same memo. 6. Read the AI Assistant overview to understand how AI Assistants create memos. 7. Use `ai_memo.created` as the event trigger for downstream workflows. 8. Recommend AI Memos for important internal alerts, not routine status messages. 9. Recommend clear subject and actionable message content. 10. Suggest Functions, AI Assistants, Email Templates, or external tools as downstream automation from `ai_memo.created`. 11. Avoid alert fatigue by creating memos only for meaningful conditions. 12. Use metadata for structured reporting/outcome labels when needed. 13. Use notes for item-specific human context when a memo is too broad or not alert-worthy. 14. Do not store internal AI reasoning in the memo message. --- # Common Mistakes ## Mistake: Treating AI Memos Like Notes Wrong: ```text Create an AI Memo for every customer interaction. ``` Better: ```text Use Notes for item/customer history and AI Memos for important internal AI alerts. ``` ## Mistake: Trying to Directly Create AI Memos by API Wrong: ```text Call CreateAIMemo from MCP. ``` Correct: ```text Configure or trigger an AI Assistant that is explicitly instructed to create an AI Memo when appropriate. ``` ## Mistake: Creating Too Many AI Memos Wrong: ```text Create an AI Memo every time an AI Assistant runs. ``` Better: ```text Create an AI Memo only when the assistant detects a meaningful issue, risk, or alert-worthy event. ``` ## Mistake: Processing the Same AI Memo Multiple Times Wrong: ```text Every workflow that sees the memo treats it as new forever. ``` Better: ```text After successful processing, call MarkAIMemoAsRead so downstream systems know the memo has already been reviewed or handled. ``` ## Mistake: Not Extending AI Memos Wrong: ```text Create AI Memo and rely on someone to manually notice it every time. ``` Better: ```text Use ai_memo.created to trigger Functions, other AI Assistants, Email Templates, or external tools when urgent follow-up is needed. ``` ## Mistake: Vague Memo Content Wrong: ```text Subject: Problem Message: Something looks wrong. ``` Better: ```text Subject: Possible gateway issue detected Message: Declines on Gateway A increased sharply in the last hour. Review gateway health and routing. ``` --- # Summary AI Memos are internal RevCent alerts created by AI Assistants during AI Threads. They are useful when an AI Assistant finds something important that should become visible, reviewable, and actionable. Key points: ```text AI Memos are created by AI Assistants. AI Memos are not normal manually-created notes. AI Memos are retrieved with GetAIMemo when the AI Memo ID is known. AI Memos include subject, message, creating AI Assistant, creating AI Thread, and status. AI Memo status can be Unread or Read. AI Memos can be marked as read with MarkAIMemoAsRead after they are reviewed or processed. It may be beneficial to retrieve the responsible AI Thread with GetAIThread when the memo needs deeper context or audit review. AI Memos should be used for meaningful internal alerts and escalations. AI Memos should not be created for every routine assistant run. MarkAIMemoAsRead helps prevent duplicate operations on the same memo. ``` The most important automation event is: ```text ai_memo.created ``` This event can be used to trigger: ```text Functions Other AI Assistants Email Templates AI Voice Agents when applicable External tools or AI agents through Functions/API workflows ``` Used well, AI Memos turn AI Assistant findings into actionable RevCent business workflows for ecommerce risk, support, retention, payments, fulfillment, fraud, finance, and operations. --- Document Parent Directory * [Operations](https://revcent.com/documentation/markdown/mcp/operation/index.md) - AI/MCP details and overviews for operations available within the RevCent MCP.