The actor model is a conceptual framework for concurrent computation that defines a way to design and implement concurrent systems. It provides a high-level abstraction for modeling concurrent entities called "actors" that communicate via message passing. Erlang, being inspired by the actor model, implements its own version of actors to enable concurrent and distributed programming.

In the actor model :

1. Actors : Actors are independent units of computation that encapsulate state and behavior. Each actor has its own isolated state, and communication between actors is achieved solely through message passing. Actors can create new actors, send messages to other actors, and perform computations based on the received messages.

2. Message Passing : Actors communicate by sending and receiving messages. Messages are immutable and asynchronous, meaning that the sender does not wait for a response. When an actor receives a message, it can pattern match on the message content and take appropriate actions. Message passing is the only way for actors to interact with each other, promoting loose coupling and isolation between actors.

3. Isolation : Actors are encapsulated and independent. They do not share memory or variables directly. Each actor manages its own state and can only modify its internal state. This isolation allows for independent and concurrent execution of actors, ensuring that changes to one actor's state do not affect others directly.

4. Lightweight Processes : In Erlang, actors are implemented as lightweight processes. Erlang processes are extremely lightweight compared to operating system processes and can be created in large numbers. The Erlang virtual machine (BEAM) efficiently schedules and switches between processes, providing concurrent execution and fairness.

5. Fault Tolerance : The actor model promotes fault tolerance by design. If an actor encounters an error or crashes, it does not affect other actors. The supervisor behavior in Erlang allows for the supervision and restart of actors, enabling fault tolerance and error recovery in distributed systems.

6. Scalability : The actor model is inherently scalable. Since actors communicate asynchronously through message passing, adding more actors does not introduce contention or synchronization issues. Erlang's lightweight processes and distributed capabilities make it easy to scale out systems across multiple nodes.