Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Repair Windows errors before they cause bigger problems3Scan for outdated or missing drivers - takes under a minuteA Jira automation rule can carry useful context from one run to the next by saving a compact summary in Jira Cloud, then adding only the relevant parts of that summary to each AI request. The stored property is application-managed state—not memory inside the model—and the prompt still has to fit the chosen model’s context window.
Separate persistent storage from the model’s context window
There are two different limits to design around. Jira can retain data between rule executions; an AI model processes only the information included in a particular request. A later run gets “memory” only when the rule retrieves stored information and includes it again. OpenAI describes the context window as the maximum tokens usable in one request (OpenAI’s conversation-state documentation).
As an Amazon Associate I earn from qualifying purchases.
This pattern is documented for Jira Cloud. Do not assume that every Automation action or property detail applies identically to Jira Data Center without checking the relevant version and app.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Choose what the rule should remember
Store a small, maintained state object rather than a transcript of every prior prompt or comment. For example, a summary rule might retain:
#1 Best Overall
- A concise summary of the issue’s current situation
- Decisions that will affect a later run
- Unresolved questions
- A timestamp or version for tracking freshness
These fields are an illustrative design, not an Atlassian-prescribed schema. Keep only information that a future rule run is likely to need, and update the summary when relevant activity occurs.
Pick a storage scope that matches the memory
| Option | Best fit | Size and scope | Access and operational considerations |
|---|---|---|---|
| Issue entity property | Memory about one issue | Atlassian documents a maximum of 32,768 bytes per property value. | Users who can edit the issue can change its property. Avoid secrets and personal data. |
| Project property | Compact state shared at project scope | Entity-property limits apply; shape the data for project-level use. | Check who can modify it and how simultaneous updates are handled. |
| App with separately controlled storage | Cross-issue state, richer access controls, or a larger store | Depends on the selected store and API. | Requires additional implementation and permission design; retrieve only needed facts. |
| Full history in every prompt | Not recommended as the default | Consumes context repeatedly and may exceed the model’s limit. | Replace with compact summaries and selective retrieval. |
For issue-scoped state, Jira Cloud Automation documents a Set entity property action. The Jira Cloud REST API v3 also provides operations to set, get, and delete issue properties; values must be valid JSON (Issue properties API). Give the key a stable, distinctive name: Atlassian notes that apps share a global property-key namespace (Jira entity properties).
One possible value shape is {"summary":"…","decisions":["…"],"open_questions":["…"],"updated_at":"…","schema_version":1}. Keep the serialized value under the documented 32,768-byte maximum. Entity properties are not a secret vault: Atlassian says, “You should never store private or personal data in entity properties.” Property edits are not merged automatically; when concurrent changes occur, the latest saved property is retained. For stricter access controls or shared state beyond Jira’s property model, assess a separately controlled store.
Rebuild a small request on each run
- Identify the trigger and relevant change. Decide what new issue activity or field change matters to this run.
- Retrieve the prior state. Read the issue property, or the appropriately scoped store, using the action or integration available in your Jira environment.
- Assemble only needed context. Combine the current fields, relevant new text, and the compact prior summary. Avoid adding unrelated comments or repeating instructions.
- Ask for a bounded update. Specify the desired response shape and keep the requested output appropriately small for the task.
- Validate and save. If the integration supports structured output, validate the returned JSON before writing the updated property. The exact wiring depends on the model action or external integration available in the target Jira environment.
Jira smart values can insert Automation data into text; Atlassian gives examples such as {{issue.summary}} in its smart-values documentation. If an earlier rule action changes data and a later action needs refreshed values, use the Re-fetch work item data action documented among Automation actions.
Budget tokens for the whole request, not just memory
Token counts cannot be reliably inferred from word counts. OpenAI’s rough estimate is that one token corresponds to about four English characters or three-quarters of a word, but the actual count varies by model, encoding, language, and text. Use the selected model’s token-counting method or request-usage data rather than treating that estimate as a limit (OpenAI’s token guide).
Budget for instructions, current Jira data, stored memory, and the response. Depending on the model, generated output and reasoning tokens also draw on the available context. Decide how much output the task needs first; allocate the remaining capacity to input. Check the chosen model’s current context window and output cap—there is no universal limit for an unspecified model. OpenAI’s guidance for oversized requests includes shortening or rephrasing prompts, removing repeated context, splitting large inputs, and summarizing or preprocessing text (token guide).
Rank #4
- Remove duplicated issue details and repeated instructions.
- Summarize older history into the state object instead of resending it.
- Retrieve only fields relevant to the present decision.
- Split independent analysis into separate requests when useful.
- Count tokens after assembling and serializing the request; JSON keys and formatting also use tokens.
Keep Jira limits distinct from AI limits
The 32,768-byte entity-property maximum is a Jira storage constraint, not a model token allowance. Jira Cloud also documents a 1 MB cap for an individual rich-text entry such as a description or comment (Atlassian’s work item field limits); that does not mean a model can accept that much text in one request.
For Forge apps specifically, Atlassian documents a 200,000-token context window, a 50,000-token-per-minute limit per model per app installation, and 100 requests per minute per installation (Forge LLM limits). Those figures apply to the Forge LLM API, not Jira Automation generally and not an external model provider’s quota.
Quick Recap
Best Value
Check the rule’s behavior and failure cases
- Property is missing: Treat this as first-run state and create a valid initial summary rather than assuming prior memory exists.
- Property is too large: Reduce or restructure the stored summary; do not move an unfiltered transcript into the next prompt.
- Prompt is too large: Trim repeated material, retrieve fewer fields, or summarize older context, then measure the assembled request again.
- Property changes unexpectedly: Review who can edit the issue or project and whether overlapping runs can overwrite one another; entity-property updates do not merge concurrent edits.
- Model output is malformed: Validate the expected structure before saving, and define how the rule should handle a failed validation.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
