Incorporate Akka SDK in intros (#32806)

Author: ennru

README.md

@@ -1,41 +1,51 @@
 Akka
 ====
-The Akka family of projects is managed by teams at [Akka](https://akka.io/) with help from the community.
 
-We believe that writing correct concurrent & distributed, resilient and elastic applications is too hard.
-Most of the time it's because we are using the wrong tools and the wrong level of abstraction.
+*Akka is a powerful platform that simplifies building and operating highly responsive, resilient, and scalable services.*
 
-Akka is here to change that.
+The platform consists of
+* the [**Akka SDK**](https://doc.akka.io/java/index.html) for straightforward, rapid development with AI assist and automatic clustering. Services built with the Akka SDK are automatically clustered and can be deployed on any infrastructure.
+* and [**Akka Automated Operations**](https://doc.akka.io/operations/akka-platform.html), a managed solution that handles everything for Akka SDK services from auto-elasticity to multi-region high availability running safely within your VPC.
 
-Using the Actor Model we raise the abstraction level and provide a better platform to build correct concurrent and scalable applications. This model is a perfect match for the principles laid out in the [Reactive Manifesto](https://www.reactivemanifesto.org/).
+The **Akka SDK** and **Akka Automated Operations** are built upon the foundational [**Akka libraries**](https://doc.akka.io/libraries/akka-dependencies/current/), providing the building blocks for distributed systems.
 
-For resilience, we adopt the "Let it crash" model which the telecom industry has used with great success to build applications that self-heal and systems that never stop.
+Akka has been downloaded more than 1 billion times and has powered thousands of systems for over 15 years.  Akka enables millions of concurrent users, terabyte stream processing, low-latency read/write data access, 99.9999% availability, and multi-region high availability and disaster recovery (HA/DR).
 
-Actors also provide the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications.
+Akka is used to build agentic AI, AI inference, transactional, analytical, digital twin, IOT, and edge-to-cloud systems. It is simple to learn and operate. Akka creates production-ready systems without requiring prior knowledge of events, threading, or distributed systems.
 
-Learn more at [akka.io](https://akka.io/).
 
-Reference Documentation
------------------------
+Akka core library
+=================
 
-The reference documentation is available at [doc.akka.io](https://doc.akka.io),
-for [Scala](https://doc.akka.io/libraries/akka-core/current/?language=scala) and [Java](https://doc.akka.io/libraries/akka-core/current/?language=java).
+The Akka core library provides:
 
-Current versions of all Akka libraries
---------------------------------------
+* Multi-threaded behavior without the use of low-level concurrency constructs like
+  atomics or locks — relieving you from even thinking about memory visibility issues.
+* Transparent remote communication between systems and their components — relieving you from writing and maintaining difficult networking code.
+* A clustered, high-availability architecture that is elastic, scales in or out, on demand — enabling you to deliver a truly reactive system.
 
-The current versions of all Akka libraries are listed on the [Akka Dependencies](https://doc.akka.io/libraries/akka-dependencies/current/) page. Releases of the Akka core libraries in this repository are listed on the [GitHub releases](https://github.com/akka/akka/releases) page.
+At Akka's core is the actor model which provides a level of abstraction that makes it
+easier to write correct concurrent, parallel and distributed systems. The actor
+model spans the full set of Akka libraries, providing you with a consistent way
+of understanding and using them. Thus, Akka offers a depth of integration that
+you cannot achieve by picking libraries to solve individual problems and trying
+to piece them together.
+
+Using the Actor Model we raise the abstraction level and provide a better platform to build correct concurrent and scalable applications. This model is a perfect match for the principles laid out in the [Reactive Manifesto](https://www.reactivemanifesto.org/).
 
-Community
----------
-You can join these groups and chats to discuss and ask Akka related questions:
+For resilience, we adopt the "Let it crash" model which the telecom industry has used with great success to build applications that self-heal and systems that never stop.
+
+Akka actors also provide the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications.
+
+Reference Documentation
+-----------------------
 
-- Forums: [discuss.akka.io](https://discuss.akka.io)
-- Issue tracker: [![github: akka/akka](https://img.shields.io/badge/github%3A-issues-blue.svg?style=flat-square)](https://github.com/akka/akka/issues)
+The current versions of all Akka libraries are listed on the [Akka Dependencies](https://doc.akka.io/libraries/akka-dependencies/current/) page. Releases of the Akka core libraries in this repository are listed on the [GitHub releases](https://github.com/akka/akka/releases) page.
 
-In addition to that, you may enjoy following:
+The reference documentation for all Akka libraries is available via [doc.akka.io/libraries/](https://doc.akka.io/libraries/), details for the Akka core libraries
+for [Scala](https://doc.akka.io/libraries/akka-core/current/?language=scala) and [Java](https://doc.akka.io/libraries/akka-core/current/?language=java).
 
-- Questions tagged [#akka on StackOverflow](https://stackoverflow.com/questions/tagged/akka)
+The current versions of all Akka libraries are listed on the [Akka Dependencies](https://doc.akka.io/libraries/akka-dependencies/current/) page. Releases of the Akka core libraries in this repository are listed on the [GitHub releases](https://github.com/akka/akka/releases) page.
 
 Contributing
 ------------

akka-docs/src/main/paradox/index.md

@@ -1,4 +1,4 @@
-# Akka Documentation
+# Akka core
 
 @@toc { depth=2 }
 

akka-docs/src/main/paradox/typed/guide/introduction.md

@@ -1,4 +1,4 @@
-# Introduction to Akka
+# Introduction to Akka libraries
 
 Welcome to Akka, a set of libraries for designing scalable, resilient systems that span processor cores and networks. Akka allows you to focus on meeting business needs instead of writing low-level code to provide reliable behavior, fault tolerance, and high performance.
 
@@ -16,7 +16,7 @@ To help you deal with these realities, Akka provides:
  * Transparent remote communication between systems and their components — relieving you from writing and maintaining difficult networking code.
  * A clustered, high-availability architecture that is elastic, scales in or out, on demand — enabling you to deliver a truly reactive system.
 
-Akka's use of the actor model provides a level of abstraction that makes it
+At Akka's core is the actor model which provides a level of abstraction that makes it
 easier to write correct concurrent, parallel and distributed systems. The actor
 model spans the full set of Akka libraries, providing you with a consistent way
 of understanding and using them. Thus, Akka offers a depth of integration that
@@ -28,10 +28,16 @@ and deep set of tools that solve difficult distributed/parallel systems problems
 in a uniform programming model where everything fits together tightly and
 efficiently.
 
-## How to get started
+## Foundational for the Akka SDK and Akka Automated Operations
+
+The Akka libraries enable us to provide
+* the [**Akka SDK**](https://doc.akka.io/java/index.html) for straightforward, rapid development with AI assist and automatic clustering. Services built with the Akka SDK are automatically clustered and can be deployed on any infrastructure.
+* and [**Akka Automated Operations**](https://doc.akka.io/operations/akka-platform.html), a managed solution that handles everything for Akka SDK services from auto-elasticity to multi-region high availability running safely within your VPC.
+
+## How to get started with the Akka libraries
 
 If this is your first experience with Akka, we recommend that you start by
-running a simple Hello World project. See the @ref[first Hello World example](../actors.md#first-example) for
+running a simple Hello World project. See the @ref[first Hello World actor example](../actors.md#first-example) for
 instructions on downloading and running the Hello World example. That example walks you through example code that introduces how to define actor systems, actors, and messages. Within 10 minutes, you should be able to run the Hello World example and learn how it is constructed.
 
 This *Getting Started* guide provides the next level of information. It covers why the actor model fits the needs of modern distributed systems and includes a tutorial that will help further your knowledge of Akka. Topics include: