The remFREE agent needs a communication path that behaves differently from an ordinary web page.
A web browser normally makes a request, receives a response, and finishes.
A managed endpoint needs something more persistent.
That is where the remFREE WebSocket gateway comes in.
The endpoint
The remFREE agent connects to the secure WebSocket endpoint:
wss://rmm.remfree.com/ws
The wss scheme means WebSocket communication protected by TLS.
Conceptually, the relationship looks like this:
remFREE Agent
|
| outbound WSS
v
Go WebSocket Gateway
|
| application coordination
v
remFREE Platform
Why not ordinary HTTP polling?
A simple management agent could repeatedly ask:
Do you have anything for me yet?
That works, but it introduces tradeoffs.
If polling is frequent, it creates unnecessary requests.
If polling is infrequent, jobs feel slow.
A persistent WebSocket connection gives remFREE a bidirectional communication channel that can remain available while the endpoint is online.
Bidirectional communication
Once the connection is established, both sides can participate in message exchange over the same persistent session.
That is useful for operations such as:
- agent status
- heartbeat coordination
- job dispatch
- job progress
- job results
- remote-session coordination
The endpoint does not need to create a brand-new connection for every individual message.
Why Go?
The WebSocket gateway is written in Go.
Go is well suited to this kind of service because it handles:
- long-running processes
- many concurrent connections
- lightweight goroutines
- network communication
- compact deployment binaries
This makes it a natural fit for the persistent connectivity layer.
Why not put everything in Laravel?
Laravel is excellent at the application side of remFREE.
It handles things such as:
- users
- authentication
- tenants
- devices
- jobs
- compliance
- patch policy
- inventory
- administrative workflows
- web UI
Persistent socket handling is a different workload.
Separating the gateway allows each part of the platform to focus on what it does best.
A useful mental model is:
Laravel = what should happen
Gateway = how the connected agent is reached
Agent = what happens on the endpoint
Agent presence
When an agent establishes and maintains communication, remFREE can update information associated with the endpoint's presence.
This includes concepts such as:
- last seen time
- connection state
- current agent version
That information helps the product determine whether a device is currently reachable.
Jobs
A job begins as application data.
For example, an administrator may request:
- inventory collection
- a script
- a screenshot
- patch remediation
Laravel creates and tracks the job.
The real-time communication layer helps that job reach the connected agent.
The agent executes the supported endpoint action and returns the result.
Conceptually:
Administrator
|
v
Laravel creates job
|
v
Gateway reaches agent
|
v
Agent executes action
|
v
Result returns to platform
|
v
Job history is updated
Why connection state is not the same as job success
A connected WebSocket tells remFREE that the endpoint communication path is available.
It does not guarantee that every requested action will succeed.
For example:
- the agent may lack a required capability
- the operating system may deny an action
- a command may return an error
- the interactive desktop may not exist
- an update operation may fail
Connectivity and execution are deliberately tracked as different concepts.
Proxies and secure gateways
Some enterprise security products handle WebSockets differently from normal HTTPS traffic.
An endpoint may successfully reach the remFREE website while its persistent agent connection fails.
In those environments, administrators should verify support for:
- WebSocket protocol upgrades
- long-lived TLS connections
- outbound TCP 443
- the remFREE hostname
- appropriate TLS inspection behavior
The important boundary
The gateway is not the whole product.
It is a specialized transport layer.
Business policy belongs in the application.
Endpoint execution belongs in the agent.
Keeping these roles separated makes remFREE easier to reason about, troubleshoot, and evolve.