[opensourcedex]

livecontext-ce is a free, open source orchestration & scheduling project written in Java and released under AGPL-3.0. It has 502 GitHub stars, 59 forks and 0 open issues, and was last pushed 12 days ago. On this registry it ranks #124 of 124 tracked projects in Orchestration & Scheduling, with 5 head-to-head comparisons available.

What is livecontext-ce?

LiveContext CE is the self-hosted, AGPL-3.0 Community Edition of the LiveContext AI automation platform, a single Docker-deployed service where a team describes a job in chat and gets back a readable workflow, scoped AI agents and a small app the team actually uses.

What it is

LiveContext is an AI automation platform that combines four things most teams otherwise wire together by hand: a chatbot, an automation tool, an app builder and an agent framework. They share one canvas, so the chat builds an automation and the same artifact runs as a Workflow, an Agent, an App and built-in data Tables. This repository is the Community Edition (CE), the full platform packaged as a single self-hosted service that is free to self-host and use in production inside an organization. It ships with a Java 21 backend and a Next.js 16 frontend, and it is Docker Compose ready.

The concrete problem it solves is the stitching tax and the black box. Teams normally assemble a chatbot, an automation tool, an app builder and an agent framework into one pipeline, then hand the whole job to a single do-everything agent whose behaviour is hard to inspect. LiveContext inverts that: the workflow decides exactly what each agent sees and what it ships, so the same job runs at a fraction of the cost, every step is auditable, and the business never sits inside a black box. It is an open-source, self-hosted alternative to n8n, Zapier and Make, with AI agents built in. Built-in tables mean workflows and agents can read, write and enrich data with no external database to wire up.

Key capabilities

  • Chat-driven builder: one message in, a working automation out, with Chat, Workflow, Agent and App on a single canvas.
  • Workflow plus App in one view: draw the automation as a readable graph, then wrap it in forms, dashboards and live approval screens that a person or an agent can act on.
  • Scoped agents: a fleet with one agent per job, each with its own model, tools, files, credit budget and full audit trail.
  • Built-in data tables: filter, search and export without an external database.
  • Data and metrics: every run charted by calls, tokens, success rate and duration, sliced per agent and per tool, so a regression can be drilled into directly.
  • Optional add-ons: interface screenshots and PDFs, and a browser agent with web search, enabled through a single env file.
  • Packaging: Docker Compose stack, with the livecontext service running database migrations and registering its tools on first boot.

Who uses it and how

  • Teams that want automation running inside their own infrastructure rather than on a vendor's hosted service, and who are willing to run a Docker Compose stack themselves.
  • Organizations replacing a Zapier or Make subscription, or consolidating a separate chatbot, app builder and agent framework onto one platform.
  • Operations groups that need per-agent credit budgets and an audit trail, so cost and behaviour stay attributable to a specific job and step.
  • Small teams standing the platform up quickly: 4 GB RAM minimum, 8 GB recommended, with the first account created at http://localhost:3000 becoming the admin.

Getting started

The fastest route is npx livecontext with Docker installed and running; it pulls the images, boots the whole stack and serves on http://localhost:3000, with npx livecontext down to stop and npx livecontext update to upgrade. Alternatively, clone the repository and run docker compose up -d from the repo root.

How it compares

Against n8n, Zapier and Make, the differences the project states are licence, hosting and data ownership: LiveContext CE is AGPL-3.0 and free to self-host and use in production inside an organization, while those products are used as hosted or vendor-operated services. Because the platform runs on the team's own infrastructure and keeps agents scoped with audit trails, business data does not sit inside a vendor black box. The cost model also differs: per-agent credit budgets and the workflow-decides-what-the-agent-sees design are presented as running the same job at a fraction of the cost of one do-everything agent.

When to use it — and when not to

A self-hoster must operate the Docker Compose stack and supply configuration for LLM keys, SMTP and ports, documented in docker/README-CE.md, by copying docker/.env.ce.example and never committing it. Teams that do not want to run Docker or manage their own keys and mail settings should not pick the CE build, and should look at the hosted version instead. The facts do not state commercial support or an SLA for the Community Edition, so it suits teams that can absorb that themselves.

project readme (upstream, from github) — read inline

LiveContext

The AI automation platform. One message in, a working automation out.

Describe the job in chat and LiveContext builds it in front of you: a workflow you can read, AI agents with scoped access and budgets you control, and a small app your team actually uses. Chat, Workflow, Agent and App in one self-hosted platform. No code to write, nothing to stitch together.

An open-source, self-hosted alternative to n8n, Zapier and Make, with AI agents built in.

GitHub stars Latest release Discussions License: AGPL v3 Java 21 Next.js Docker Compose Self-hosted

The builder, built by chat: one message in, a working automation out. Five real scenarios, one loop. Watch it full size · Try the hosted version

⭐ If LiveContext looks useful, give it a star. It helps other teams find it.

Build it once. It runs as all four.

Most teams wire together a chatbot, an automation tool, an app builder and an agent framework. LiveContext is all four on one canvas, every agent scoped, budgeted and audited, and you can see exactly what each one did. The chat (shown above) builds it; here is what it runs as:


Workflow + App
The workflow and the app it drives, in one view. Draw the automation as a readable graph, then wrap it in a real interface: forms, dashboards and live approval screens your team or an agent can act on.
Agents
A fleet of scoped agents, one per job: each with its own model, tools, files, credit budget and full audit trail. No black box.

Tables
Built-in data tables your workflows and agents read, write and enrich. Filter, search and export, with no external database to wire up.
Data & metrics
Every run charted: calls, tokens, success rate and duration, sliced per agent and per tool. Spot a regression and drill straight into it.

The workflow decides exactly what each agent sees and what it ships, so the same job runs at a fraction of the cost of a do-everything agent, every step is auditable, and your business never sits inside a black box.

This repository is the Community Edition (CE): the full platform as a single self-hosted service (see LICENSE). It is free to self-host and use in production inside your organization.

Requirements

  • Docker Engine 24+ with Compose v2 (or Docker Desktop 4.x and later)
  • 4 GB RAM minimum, 8 GB recommended

Quick start

The fastest way is one npm command (Docker must be installed and running):

npx livecontext

It pulls the images, boots the whole stack, and serves on http://localhost:3000. npx livecontext down stops it and npx livecontext update upgrades it. The CLI wraps Docker Compose, it does not replace Docker.

Or run Docker Compose directly from a clone of this repo:

# From the repo root:
docker compose up -d

# Watch it come up. The "livecontext" service runs database migrations and registers
# its tools on first boot; wait until it reports "healthy" and "frontend" is up:
docker compose ps

Then open http://localhost:3000 and create the first account (the first user becomes the admin). Two optional add-ons (interface screenshots/PDFs, and a browser agent with web search) are one env file away when you want them, see Optional features below.

Configuration (LLM keys, SMTP, ports) is documented in docker/README-CE.md. Copy docker/.env.ce.example to set your own values, and never commit it.

Running it on a server, NAS or VPS

Nothing extra to build. Publish both ports (3000 for the web UI, 8080 for the backend) and open the app at that machine's address: http://192.168.1.50:3000 talks to http://192.168.1.50:8080 on its own. If you put a reverse proxy in front and serve everything on a single origin, set GATEWAY_PUBLIC_URL on the frontend service to the browser-facing backend URL instead.

Deploying through Portainer, Coolify, Dokploy or a similar platform: see templates/README.md.

Images

Built for linux/amd64 and linux/arm64, so the same tag runs on an ordinary server and on Apple Silicon, a Raspberry Pi, Ampere or Graviton. Docker picks the right one for your machine. The Compose file pulls from GHCR:

ghcr.io/livecontext-ai/livecontext-ce
ghcr.io/livecontext-ai/livecontext-ce-frontend
ghcr.io/livecontext-ai/livecontext-ce-bridge
ghcr.io/livecontext-ai/livecontext-ce-screenshot-renderer   # opt-in renderer profile

Each release is tagged vX.Y.Z (immutable) plus vX.Y, vX and latest if you would rather track a line than pin an exact version.

Optional features

Two heavy features are opt-in and start with no container by default, keeping the base stack light. Each is enabled by a bundled env file (it turns on both the Docker profile and the matching app setting in one shot):

  • Interface screenshots and PDFs (renderer profile). Adds a headless Playwright/Chromium sidecar (~1 GB image) so interface nodes can render a PNG screenshot or a PDF. Enable it with:
    docker compose --env-file docker/.env.ce.renderer up -d
  • Browser agent and web search (browser-agent profile). Adds a Chromium browser-use container plus a SearXNG metasearch sidecar (~2 GB) so agents can browse pages (agent_browse) and run web_search. Enable it with:
    docker compose --env-file docker/.env.ce.browser-agent up -d

Run both by passing both env files (repeat --env-file). See docker/README-CE.md for details and tuning.

Both add-ons need this repository: the env files above are not part of the livecontext npm package and npx livecontext passes no --env-file, so neither can be enabled through npx. Clone the repo and use docker compose directly to turn them on.

What's in the box

  • Workflow engine. Visual builder and execution engine with parallel branches, loops, signals, human-approval steps, and triggers (schedule, webhook, chat, form, datasource).
  • AI agents. Chat agents that design, build and run workflows, with per-workspace skills, scoped tool access, per-agent credit budgets and per-agent metrics.
  • Integration catalog. 700+ ready-made integrations seeded at first boot, fully offline. Add your own as OpenAPI specs.
  • Interfaces and apps. Small web pages served by your workflows (forms, dashboards, approval screens), shareable as standalone apps.
  • Tables. Built-in data tables your workflows and agents can read and write.
  • One backend. All backend services run as a single monolith JAR, with PostgreSQL, Redis, an S3-compatible object store and a lightweight tools bridge as its dependencies, plus the Next.js frontend. It all comes up with one docker compose up.

Why self-host LiveContext

  • You stay in control. Per-agent credit budgets, scoped access, a full audit trail and per-agent metrics. No black box.
  • Far fewer tokens. The workflow constrains exactly what each agent sees and ships, so jobs cost a fraction of a do-everything agent.
  • Org-grade access. Organizations and workspaces with role-based access control.
  • Yours to run. The same platform on your own infrastructure.

Managed version

Prefer not to run your own infrastructure? The managed service, with an always-current integration catalog and hosted account management, lives at livecontext.ai. Those hosted-only features are not part of the Community Edition.

Building from source

CE runs from prebuilt images (the Quick start above pulls them). The full source is in this repo. To build the images yourself instead of pulling, use the per-service Dockerfiles: backend/monolith-service/Dockerfile (Java 21, the ce Maven profile), frontend/Dockerfile (Node 20), and mcp/bridge/Dockerfile.

Security

Please report vulnerabilities privately. See SECURITY.md.

License

LiveContext CE is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0), see LICENSE. You are free to use, self-host, modify and redistribute it, including commercially. One condition matters most: if you run a modified version as a network service, the AGPL requires you to make the corresponding source of your changes available to that service's users.

The LiveContext name and logo are trademarks of their owner and are not covered by the AGPL, see TRADEMARKS. Third-party components ship under their own licenses, see NOTICE and THIRD_PARTY_NOTICES.

⭐ If LiveContext is useful to you, star the repo. It is the simplest way to help other teams discover it, and it means a lot to a small team. Questions or ideas? Open a Discussion.

Frequently asked questions

Is livecontext-ce free to use?

livecontext-ce is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does livecontext-ce do?

The AI automation platform, self-hosted. Describe the job in chat and LiveContext builds it: readable workflows, scoped AI agents, and small apps your team uses

What is livecontext-ce written in?

livecontext-ce is primarily written in Java. Its source is publicly available at https://github.com/livecontext-ai/livecontext-ce, and it has 502 GitHub stars.