The general availability of the Forge LLMs API marks a turning point for developers who want to embed sophisticated language models directly into Atlassian‑hosted applications without compromising security or incurring operational overhead. Until now, adding AI capabilities often meant standing up separate model servers, managing API keys, and wrestling with data‑egress policies that could block adoption in regulated environments. By moving out of preview, Atlassian signals that the service is stable, fully supported, and ready for production workloads at scale. This release dovetails with a broader industry shift where enterprises demand AI that is not only powerful but also provably compliant with internal governance frameworks. For teams already invested in Jira, Confluence, or Bitbucket, the ability to call a large language model from within the same trust boundary eliminates a major friction point. It also opens the door for rapid experimentation: product managers can prototype a summarization feature in a sprint, while security teams retain confidence that no customer data leaves the Atlassian cloud. In the following sections we will unpack what the API offers, how early adopters are putting it to work, and what practical steps you can take today to start building AI‑native experiences that feel like a natural extension of your existing workflow.
At its core, the Forge LLMs API is a thin, developer‑friendly wrapper that grants access to a selection of large language models hosted on Amazon Bedrock, all while keeping the compute and data storage inside the Atlassian platform. When you invoke the API, the request travels only as far as the Forge runtime; the model inference occurs in a secure, isolated environment that never exposes your workspace content to third‑party services. This arrangement removes the need to provision GPU clusters, manage model versioning, or negotiate separate licensing agreements with AI vendors. Instead, you focus on writing the logic that decides when and how to call the model—whether that is to generate a short description from a lengthy issue thread, to suggest a next step in a workflow, or to translate a piece of documentation into another language. The SDK abstracts away authentication details, so you do not have to handle API keys or worry about token rotation. Because the service is billed through your existing Forge subscription, there are no surprise line items on your invoice, and capacity planning aligns with the rest of your app’s resource usage. In short, the API gives you the power of a frontier LLM without the operational baggage that typically accompanies external AI integrations.
The model lineup available at launch reflects a careful balance between performance, cost, and versatility. Developers can choose among three tiers of the Claude family—Haiku for lightweight, fast responses; Sonnet for a strong mix of quality and efficiency; and Opus for the most demanding reasoning tasks. With the general availability release, Atlassian has upgraded the Sonnet offering to version 5 and made Opus 4.7 and Opus 4.8 generally available, providing access to newer capabilities such as improved instruction following and reduced hallucination rates. All of these models are served through Amazon Bedrock, which means they benefit from the same robustness, scaling, and monitoring features that AWS provides to its enterprise customers. Bedrock’s multi‑model support also lays the groundwork for future expansion; Atlassian has indicated that additional model families—potentially including open‑source alternatives or specialized domain models—will be added as the ecosystem matures. This flexibility lets you match the model’s strength to the specific problem at hand, avoiding over‑provisioning for simple tasks while still having a powerful option ready when deep analysis is required. The result is a tunable AI layer that can evolve alongside your application’s needs without requiring you to rewrite integration code.
Data residency and compliance have historically been the biggest hurdles for teams considering AI‑enhanced features, especially in industries such as finance, healthcare, or government where regulations forbid sending sensitive information outside a vetted cloud boundary. The Forge LLMs API directly addresses this concern by ensuring that every prompt, every piece of context, and every generated response remains inside the Atlassian cloud for the entirety of its lifecycle. Because the models run on Bedrock instances that are provisioned within the same tenancy as your Forge app, there is no data egress to external endpoints. This architectural guarantee enables apps that use the API to qualify for the “Runs on Atlassian” badge, a signal to enterprise buyers that the add‑on meets strict data‑protection standards. For security teams, the badge simplifies vendor assessments: they can verify compliance by reviewing the app’s listing rather than conducting a custom audit of data flows. Moreover, the elimination of third‑party AI calls reduces the attack surface associated with credential leakage or unauthorized model access. In practice, this means that a compliance officer can approve an AI‑powered summarizer for Jira Service Management with the same confidence they would grant to a native Atlassian feature, accelerating the procurement process and reducing time‑to‑value for AI initiatives.
Since the preview opened in June, adoption has accelerated faster than many anticipated. More than one hundred distinct Forge applications have already moved from experimentation to production using the LLM API, and roughly twenty of those are publicly listed on the Atlassian Marketplace, serving real customers today. The remaining eighty or so are internal builds, proof‑of‑concept projects, or private extensions that teams are using to solve niche problems within their own organizations. This split illustrates two complementary pathways: Marketplace partners are leveraging the API to enrich their commercial offerings with intelligent features, while end‑user customers are exploiting the same capability to tailor bespoke automations that would be uneconomical to develop through traditional software engineering. Early metrics show that the median time from first API call to a market‑ready feature is measured in weeks rather than months, underscoring the speed advantage of consuming a managed model service. Moreover, the diversity of use cases—ranging from risk‑assessment bots that ingest regulatory texts to diagramming assistants that turn natural language into structured visuals—demonstrates the API’s breadth. As the developer community continues to explore, we can expect a growing catalog of reusable components, patterns, and sample apps that lower the barrier for the next wave of adopters.
Looking at the applications that have already surfaced, several recurring patterns emerge. One of the most common is workflow automation: developers use the LLM to interpret free‑form user input—such as a short description of a desired outcome—and translate it into concrete actions like creating a ticket, assigning a priority, or triggering a CI/CD pipeline. Another frequent pattern is content transformation, where the model summarizes long comment threads, extracts action items from meeting notes, or generates release‑notes drafts from commit messages. Language translation is also popular, especially for global teams that need to convey knowledge base articles or support responses in multiple languages without maintaining separate translation pipelines. A less obvious but increasingly valuable pattern is data enrichment: the model can suggest relevant documentation, link to related issues, or propose tags based on the semantic content of a piece of text. These patterns share a common trait—they all take unstructured or semi‑structured information and impose structure that makes it easier for downstream processes to consume. Because the LLM operates within the Forge sandbox, developers can iterate on prompts and fine‑tune output formats without worrying about corrupting production data or breaching governance rules. The result is a tighter feedback loop between idea and implementation, empowering teams to ship AI‑driven improvements at a pace that matches the velocity of modern DevOps practices.
Beyond generic productivity aids, the Forge LLMs API is inspiring domain‑specific solutions that address pain points unique to particular disciplines. In software testing, for example, teams are building assistants that read a test case written in plain language and automatically generate the corresponding code in a target framework, reducing the manual effort required to keep test suites in sync with evolving specifications. Procurement departments are experimenting with bots that parse vendor contracts, flag risky clauses, and suggest alternative wording that aligns with corporate policy. Risk management applications are using the model to scan internal policies and external regulations, producing concise briefings that highlight potential compliance gaps before they become incidents. Even creative fields such as user‑experience design are seeing value: designers feed rough sketch descriptions into the model and receive suggestions for layout improvements, accessibility tweaks, or copy variations that adhere to brand guidelines. These specialized apps benefit from the model’s ability to understand nuanced context while still being grounded in the specific terminology and rules of their field. Because the Forge platform provides tight integration with Atlassian products—such as the ability to read issue fields, update wiki pages, or trigger webhooks—the LLM can act as a knowledgeable intermediary that bridges raw user intent with concrete system actions. As more developers share their domain‑focused components, a growing library of reusable AI skills will emerge, making it easier for others to assemble sophisticated solutions without starting from scratch.
From a developer experience standpoint, the Forge LLMs API strives to be as frictionless as possible. The official SDK is available for the standard Forge languages—JavaScript/TypeScript for frontend modules and Java for backend functions—so you can pick the language that matches the rest of your codebase. Adding the dependency is a single line in your manifest, and initializing the client requires no API keys, tokens, or secret management; the Forge runtime automatically supplies the necessary credentials based on your app’s entitlement. A typical call looks like this: you construct a prompt string that may include dynamic data from the current issue or comment, pass it to the generate method, and handle the returned text in a callback or promise. Because the SDK handles retries, timeout configuration, and streaming options, you can focus on the business logic rather than the plumbing of HTTP requests or JSON parsing. Error handling is straightforward, with distinct codes for rate limiting, model‑specific failures, and validation issues, allowing you to present meaningful feedback to end users. Documentation includes ready‑to‑run examples for common tasks such as summarization, translation, and classification, which you can copy into your project and adapt within minutes. This low‑friction approach means that even developers with limited machine‑learning background can start experimenting with AI features in a single afternoon, accelerating innovation cycles across the organization.
Operationally, consuming models via the Forge LLMs API eliminates several cost centers that traditionally accompany AI integration. First, there is no need to purchase or maintain GPU‑based inference servers; the underlying compute is shared and elastically scaled by AWS Bedrock, and you pay only for the actual inference requests your app makes. Second, you avoid the overhead of model lifecycle management—version upgrades, security patches, and performance tuning are handled by Atlassian and AWS behind the scenes. Third, because the service is metered through your existing Forge subscription, there is no separate billing account to monitor, no additional invoices to reconcile, and no risk of unexpected charges stemming from data transfer or storage fees. This predictability simplifies budgeting for product managers and makes it easier to justify AI investments to finance stakeholders. From a performance perspective, the close proximity of the model runtime to your Forge functions reduces latency compared to a round‑trip to a public‑API endpoint, which can be particularly beneficial for interactive features where users expect near‑instant responses. Finally, the operational model aligns with Atlassian’s broader commitment to reliability: the LLM infrastructure inherits the same uptime SLA, monitoring, and incident‑response processes that power the core platform, giving enterprises confidence that AI‑enhanced features will be as available as any other part of their workflow.
The Forge LLMs API does not exist in isolation; it is the latest piece in a growing suite of AI building blocks that Atlassian is assembling for its developer ecosystem. Alongside the LLM offering, the platform already provides custom Rovo agents and skills—pre‑packaged, reusable components that encapsulate common AI behaviors such as sentiment analysis, entity extraction, or conversational flow. Developers can combine an LLM call with a Rovo skill to create sophisticated agents that, for example, receive a user query, retrieve relevant knowledge‑base articles via a Rovo skill, synthesize an answer using the language model, and then execute a follow‑up action like updating a ticket or posting a comment. This modular approach encourages reuse and reduces duplication of effort, much like how traditional software libraries accelerate development. Looking ahead, Atlassian’s roadmap hints at additional model families, enhanced prompt‑caching mechanisms, and tighter integration with the Analytics service to provide usage insights and cost attribution. By positioning the LLM API as a foundational layer rather than a one‑off feature, Atlassian signals its intention to make AI a default consideration in every new Forge project, much like authentication or webhooks are today. For organizations building long‑term product strategies, this means that investing in Forge‑based AI now will pay dividends as the platform continues to evolve and expand its intelligent capabilities.
If you are ready to start building with the Forge LLMs API, the first step is to consult the official documentation, which walks you through adding the SDK, configuring your manifest, and making your first model call. The guides include language‑specific snippets, best‑practice notes on prompt engineering, and advice on handling variable‑length outputs safely. Next, consider attending the live walkthrough scheduled for August 4th, where Atlassian engineers will demonstrate real‑world examples—such as a Jira Service Management bot that translates customer requests on the fly and a Confluence macro that generates meeting‑minutes drafts from raw notes. Seeing the code in action helps cement the concepts and reveals subtle details like how to stream partial responses for a smoother user experience. After you have a working prototype, run it against a sandbox instance of your product to validate that data never leaves the Atlassian trust boundary; you can enable audit logs to confirm that all model interactions remain internal. Finally, think about how you will measure impact: define key performance indicators such as time saved per ticket, reduction in manual documentation effort, or improvement in customer satisfaction scores. Collecting this data early not only helps justify further investment but also informs iterative refinements to your prompts and model selection, ensuring that the AI feature delivers tangible value as it scales.
In summary, the general availability of the Forge LLMs API removes the most significant barriers to adopting AI within Atlassian‑hosted applications: operational complexity, data‑governance risk, and unpredictable cost. By keeping model inference inside the platform’s secure boundary, Atlassian gives enterprises the confidence to experiment with powerful language models while staying compliant with internal policies. The early traction—over a hundred production apps, dozens of Marketplace listings, and a vibrant pipeline of internal projects—demonstrates that developers are already translating this capability into real‑world benefits across workflow automation, content transformation, and domain‑specific problem solving. Looking forward, the API’s evolution will likely bring more model choices, lower latency through edge optimizations, and deeper integration with Atlassian’s emerging AI services such as Rovo agents and analytics. For decision‑makers, the practical advice is clear: start small, measure rigorously, and expand gradually. Pick a high‑impact, low‑complexity use case—like auto‑summarizing long issue threads or translating knowledge‑base articles—to build familiarity and prove value. Then, iterate on prompt design, monitor usage metrics, and consider combining the LLM with reusable Rovo skills to create more sophisticated agents. By treating the LLM API as a foundational component rather than a novelty, you position your team to harness the next wave of intelligent automation without sacrificing security, reliability, or speed.