Introducing Quark: Autonomous AI Agents for Everyday Work

The problem with today's AI agents

AI agents are moving from research demos to production systems. But most frameworks assume you'll run agents in someone else's cloud, with opaque execution and limited control over what your agents can do.

For enterprises, this creates real problems:

• No execution boundaries. Agents can take arbitrary actions without guardrails.
• Opaque behavior. You can't audit what happened or why.
• Cloud dependency. Your data flows through external infrastructure.
• Flat architectures. No way to model organizational hierarchies or delegation.

We built Quark to solve these problems.

What Quark is

Quark is an open-source runtime for autonomous multi-agent AI. Your agents run on your machine, with every action auditable and reversible. No cloud dependency, no data leaving your infrastructure.

The architecture has four core components:

• Supervisor — manages the lifecycle of Spaces and resource allocation
• Runtime — the execution engine that hosts and runs agents
• CLI — developer interface for building and managing Spaces
• Web Channel — user-facing interface for interacting with agents

Spaces: Infrastructure as Code for AI agents

A Space is your workspace and execution environment — like a Docker image for agents. You define everything in a Quarkfile:

quark: "2026.04"

meta:
  name: healthcare-intake
  version: 1.0.0

space:
  type: healthcare
  execution_mode: assistive

model:
  provider: anthropic
  name: claude-sonnet-4-20250514

plugins:
  skills:
    - ref: quark/medical-terminology
    - ref: quark/hipaa-compliance
  binaries:
    - ref: quark/pdf-parser

main_agent:
  prompt: ./prompts/main-agent.md
  sub_agents:
    - name: triage-bot
      prompt: ./prompts/triage.md
      consumes: [patient-forms]
    - name: billing-reconciler
      prompt: ./prompts/billing.md

inboxes:
  - name: patient-forms
    type: queue
    retention: 7d

channels:
  - type: web
    port: 3000

One file. Version-controlled. Reproducible across environments.

Hierarchical agents with bounded execution

Quark enforces a strict hierarchy. The Main Agent acts as Space Manager, responsible for system-level decisions and orchestrating Sub-agents.

Sub-agents can spawn their own Sub-agents, creating a delegation tree that mirrors how real organizations work. Task allocation and permissions flow strictly top-down.

Three execution modes give you control over autonomy:

• Autonomous — unsupervised execution with defined termination conditions
• Assistive — human-in-the-loop approval before state changes
• Workflow — deterministic DAG execution for compliance-critical processes

Inboxes and Channels

Inboxes solve async data ingestion. External systems push documents, API events, or messages to Inboxes. Sub-agents subscribe and process messages as they arrive. No polling, no bottlenecks.

Channels enable omnichannel collaboration. Users interact with agents through Web, Telegram, WhatsApp, or custom interfaces. Each interaction creates a Session — an isolated conversational context that never pollutes the agent's internal work state.

Plugins: Skills + Binaries

The plugin system separates what agents know from what they can do:

• Skills — LLM instructions and schemas that teach agents how to use capabilities
• Binaries — executable code that performs the actual work

Plugins can be loaded statically via Quarkfile or discovered dynamically at runtime.

Open source

Quark is released under the Apache 2.0 license. All four core components are open source. No feature gating, no artificial limitations.

We believe infrastructure for AI agents should be transparent. If you're going to trust a system to orchestrate autonomous agents, you should be able to read every line of code.

Getting started

Create your first Space:

quark space init my-project
quark space run
quark activity

Read the getting started guide for a complete walkthrough, or explore the use cases to see how enterprises deploy Quark across healthcare, operations, software development, and more.