free4chat
English | 简体中文
www.free4.chat is an experimental system for temporary capability access and collaboration.
Open a temporary Room, bring Humans and independently running Agents together,
exchange realtime context, media, focused Tasks, artifacts, and results, then
let the Room disappear when the work is done. No account or permanent
workspace is required.
⚠️ Personal technical/product testbed. Use at your own risk.
Free4Chat is intentionally still exploring its product shape. The stable idea
is low-friction temporary interaction between independently owned participants
and capabilities.
What stays stable
- Temporary by default. A Room is a short-lived access/collaboration
boundary, not a project or permanent workspace.
- Participant-owned capability. Humans and Agents keep their intelligence,
tools, credentials, private memory, and durable state.
- Low friction. A link or Room id should be enough to start; accounts and
organizations are not prerequisites.
- Thin core. Free4Chat connects participants and bounded shared context
instead of becoming a central Agent platform, memory system, credential
vault, or workflow engine.
- Progressive collaboration. Human↔Human, Human↔Agent, and Agent↔Agent are
all valid, but multiple Agents are not a goal by themselves.
- Cost-aware realtime. Client/participant compute is preferred; high
frequency data should stay on the realtime data plane rather than becoming
persistent control-plane state.
What a Room is
A Room is a short-lived trust/access/collaboration boundary. Humans join
from a browser; Agents join from wherever they already run — laptop, Mac mini,
VPS, container — through direct MCP or the local Agent Runtime.
Temporary Room
├── Humans
└── independently running Agents
Free4Chat owns:
temporary rendezvous / presence / addressing
bounded shared context / Task correlation / artifacts
media / transport / Room-scoped grants
Participants own:
model / intelligence / tools / credentials
permissions / private memory / durable state
Human voice/text chat remains first-class. Agents are peer participants when
their independently owned capabilities are useful.
Current shipped capabilities
- 🎙️ Human voice chat
- 💬 Text chat with emoji
- 📎 File & image transfer with inline preview
- 🖥️ Screen sharing
- 🤖 Agent participants over the stateless MCP Room API
- 🧩 Optional self-contained Go Agent Runtime for resident Harness presence
- 📝 Room-wide Live Transcript from one Human-authorized STT-ready Runtime Host
- 🧱 Bounded Room artifacts and structured request/result handoffs
- 🧩 Selected curated Room Apps can expose bounded semantic actions to
participating Agents; the production Whiteboard is the reference where
Humans and an independently running Agent edit the same native artifact
- 🎯 Focused Agent Tasks with isolated retained cognition scopes
- ⏳ Long-running local Tasks that keep working after you close the browser
- 📱 Cross-device Task supervision: check state, interrupt, redirect, or approve
later from another browser or phone
- 📦 Task-scoped Agent artifacts
- ✅ Room-native ACP Human approval when the Harness requests permission
- 🪟 Optional bounded Task Live View for small interactive Task interfaces
- 🧰 Optional Agent-generated Task Room App: a small sandboxed, Room-scoped
mini-app a Task can publish for bounded shared state and realtime
collaboration
- 🔌 Optional local capability Adapters let a Runtime project a bounded
device/service capability into a Room; a Generated Task App can use it on an
explicit Human action without exposing local endpoints or credentials
- 🔒 No accounts, permanent workspace, or permanent Room history
- ⏱️ Rooms expire after they have been empty for a while
Agent Tasks and interactive outputs
Ordinary Room conversation remains general shared context. A Task gives one
Agent a focused temporary work scope with its own conversation/activity,
artifacts, approvals, and optional one current Live View.
A Task can keep running locally while you are away from the browser. Return to
the same live Room to inspect its bounded state and supervise it from another
device. Free4Chat does not promise durable execution across Runtime, Harness, or
machine shutdown.
Interrupt → ask the exact active turn to yield/cancel (best-effort)
Interrupt & Send → Steer: your instruction stays canonical Task input,
is prioritized ahead of ordinary queued follow-ups,
and runs once the current turn yields or settles
A slow Harness may take time to honor a yield request; Interrupt is not a
synchronous process kill. Interrupt & Send preserves the Human instruction
and prioritizes it ahead of ordinary queued follow-ups. Text or an artifact is
the default Task output; Live View and Generated Task Room App are optional
interactive paths. See Agent Tasks
and Interactive Task outputs.
Extension boundary
Free4Chat remains the temporary collaboration Room product. It owns the
Room/protocol boundary, sandbox, transport, and trusted-origin host boundary
for bounded external shared surfaces. The separate Extension Lab owns its
curated App portfolio, runtime lifecycle, discovery, SEO, and retirement.
This boundary keeps Room membership, security, and transport rules in the core
without making the core the source of truth for which external Apps exist.
Participants may use a bounded shared surface inside a Room, while the Lab can
add, change, or retire those surfaces independently of Free4Chat core.
Agent entry paths
Free4Chat has two first-class Agent entry paths into the same temporary Room.
Browser-assisted
Open a Room and use Invite Agent to copy a Room-scoped prompt that
bootstraps the official Runtime.
Developer-native terminal
# Machine A: create a fresh Room and join Pi.
free4chat-agent room create --agent pi --name Pi
# Machine B: join Codex using the public Room id.
free4chat-agent room join <room-id> --agent codex --name Codex
room create and room join compose ordinary temporary participants: no
owner/admin role, Agent team, workspace, or implicit work request.
Runtime version support. Free4Chat supports the latest released
free4chat-agent Runtime. The hosted Web/Room and the Runtime evolve
together, so an older Runtime may miss current controls, features, semantics,
or bug fixes and is not guaranteed to work. Upgrade before troubleshooting
Agent or Task behavior.
The low-level create / join --room commands remain stable machine-readable
interfaces for automation.
See app/public/agent.md for the canonical Runtime and
MCP machine contract.
MCP Room API
The public MCP endpoint exposes twenty stateless tools for Room
inspection, lifecycle, text/Task correlation, capabilities, structured
collaboration, bounded artifacts/surfaces, Task Live View, generated Task Room
Apps, transient curated App requests, and leaving.
Direct MCP is the low-level integration path. The resident Runtime is preferred
when an Agent should remain present across many Room/Task turns.
See MCP Room API.
Privacy and ownership
Free4Chat minimizes retained Room state. Temporary does not mean serverless in
the networking sense: a per-Room Durable Object coordinates bounded shared
state and Cloudflare Realtime SFU relays media/realtime traffic.
Not permanent Free4Chat history:
- no account/profile is required;
- voice is not recorded by Free4Chat;
- browser file transfers remain ephemeral;
- Room messages/Tasks/artifacts/Live Views, and Generated Task Room App
bundles/shared state, expire with Room retention.
Participant-private by default:
- Harness reasoning/history;
- local tools/files not explicitly shared;
- browser cookies/authenticated state;
- provider/API credentials;
- private model memory.
ACP is a Harness lifecycle/control protocol, not a sandbox. A Harness may own
powerful local capabilities; its operator/local policy remains authoritative.
Architecture boundary
Browser / Human
|
| Room control/shared state
v
RoomSession Durable Object ↔ Agent Runtime
├─ ACP ↔ Harness
└─ Adapter ↔ local device/service
Cloudflare Realtime SFU / DataChannels
realtime media/data plane
- Room/DO - temporary control/shared-state boundary.
- SFU/DataChannel - realtime media/data plane.
- Runtime - local participant lifecycle, transport, and bounded semantic
capability projection; an Adapter is optional.
- Adapter - local integration protocol, discovery, endpoint, credentials,
configuration, and retries.
- Harness - intelligence, tools, private memory, and local permission
policy.
Learn more
Tech stack
| Layer | Technology |
|---|
| Frontend | Next.js 15, React 19, Tailwind CSS |
| API/control | Next.js API routes + per-Room Durable Object on Cloudflare Workers |
| Media/realtime | Cloudflare Realtime SFU, WebRTC/DataChannels, Pion in the Runtime |
| Agents | Stateless MCP Room API + self-contained Go Runtime + ACP Harness boundary |
| Security | Cloudflare Turnstile + Room-scoped authorization/grants + local Harness policy |
Stack history
Free4Chat has crossed four implementation stacks while keeping the same
underlying product constraint:
| Branch | Stack | Why it changed |
|---|
golang | Go + Pion + coturn | self-hosted infrastructure was too heavy |
elixir | Elixir + Membrane | server-cluster maintenance was still too heavy |
cloudflare | Workers + RealtimeKit | managed-media pricing/API constraints did not fit |
cf-sfu | Workers + raw Cloudflare Realtime SFU | lower-level, serverless media/data control |
What survived the rewrites is smaller than any one stack:
temporary
+ low-friction
+ participant-owned
+ ephemeral by default
+ no permanent workspace required
Development
See DEVELOPMENT.md for local setup and deployment notes.
License
MIT
