BlogPricing
Sites
Approved files, external collaboration, permissions, Q&A, redaction, watermarking, content automation, signing, analytics, templates, and evidence
External Collaboration & Sharing
Secure document sharing, permissions, notifications, Q&A, in-app viewing, and approved content workflows
Organization Policy & Governance
Organization policy, governed records, signed evidence export, verification, access review, and lifecycle controls for sensitive Sites
Content Automation
Import websites on a schedule, extract metadata, and keep Sites, Public Chat, search, and agents current
Analytics
Page-level analytics, reading depth, search analytics, AI usage, access review, audit trail, and insights reports
Q&A and Notes
Private stakeholder questions, PDF anchors, reviewer answers, AI suggestions, notes, and announcements
Document Signing
Request signatures, verify signers, route fields, and generate audit-ready completion files and certificates
Redaction and Watermarking
Dynamic PDF watermarks, AI-assisted redaction, OCR-aware matching, preview-as-role validation, and role-aware delivery
Desktop Sync App
Two-way synchronization between desktop folders and Clear Ideas Sites with pause, resume, and manual sync controls
AI
Governed chat, semantic search, private model routing, and public website AI grounded in approved Site content
AI Chat
Ask questions across approved Site content and receive cited answers inside a governed workspace
AI Enhanced Search
Permission-aware semantic search across approved Site content, extracted text, OCR, and metadata
Private Models
Private model and Zero Data Retention provider paths for governed chat, agents, and document AI, with organization policy controls
Public AI Chat
Expose approved Site content through a controlled website assistant with lead capture, brand voice, allowed origins, and visitor tools
Agents
Governed agents, builders, source connections, triggers, generated files, run traces, and evidence
Agents
Repeatable AI processes that run against governed Sites with approved tools, triggers, review gates, generated files, and signed evidence
Agent Builder
Build, import, edit, and share repeatable agents with variables, source policies, generated outputs, and validation warnings
Agent Designer
Describe the process you need and generate a governed agent draft you can refine visually
Agent Connections
Connect agents to approved Sites and external systems with read/write modes, tool allowlists, authentication, egress controls, and evidence settings
Open Source
Open source software and tools that power the Clear Ideas platform.
Agent Runtime
Portable agent manifests resolved into durable, dependency-aware execution graphs across local and remote infrastructure
Community Edition
Self-host the open-source Clear Ideas collaboration platform in your own environment
Solutions
Solutions Overview
Due Diligence & Deal Rooms
Client Portals & File Exchange
Secure Document Sharing
Audit-Ready External Collaboration
Board & Investor Reporting
Audit & Compliance
Governed Sites
Governed Agents
by Industry
Mergers & Acquisitions
Financial Services
Legal & Professional Services
Manufacturing
Not for Profit Organizations
Board Management & Governance
Real Estate
Property Management
Investment Management & Capital Markets
Resources
Site Templates
Compare Clear Ideas
Book a Demo
Support Center
Announcements
Changelog
About Clear Ideas
Security & Trust
Governance & Evidence
Community Edition
Agent Runtime
LoginStart Free

Open source agent infrastructure

Clear Ideas Agent Runtime

Define portable agents as declarative manifests and run them through a standalone TypeScript runtime—locally, inside your application, or on remote compute. Native authorization, sandboxing, durable state, and streaming events are built in. Models and infrastructure remain under your control.

View on GitHub Read the documentation

Version 0.1.0 available now

release-brief.agent.yaml
schemaVersion: '1.0'
id: release-brief
name: Release brief

model:
  provider: openai
  model: gpt-5.6

variables:
  - key: topic
    type: string
    requiresOverride: true
  - key: audience
    type: string
    value: customers

steps:
  - id: draft
    type: prompt
    systemPrompt: Write concise release briefs.
    prompt: Draft a brief about {{ topic }} for {{ audience }}.
    outputVariable: draft

  - id: review
    type: prompt
    prompt: Improve this brief without adding claims: {{ draft }}
    includeInFinalOutput: true
Standalone
No hosted service required
Declarative
Agents are portable data
Durable
Checkpointed and resumable
Provider-neutral
Connect the infrastructure you use

Dependency-aware execution

Agent Runtime resolves manifests into execution graphs.

Before a run begins, Agent Runtime analyzes step outputs and variable reads to build an ordered execution plan. Eligible independent branches run concurrently, dependent work waits for its inputs, and results commit in manifest order. Branching tasks can complete substantially faster without changing the manifest.

A 26-second visualization of a manifest resolving into a live execution graph: context streams first, independent drafting and evidence branches fan out, then the graph reconverges for review and final output.

Portable contracts

Define the agent separately from the run and the infrastructure.

The agent describes its steps, variables, tools, and outputs. The run provides invocation values. The host connects models, credentials, state, generated files, and compute.

01

Agent Manifest

A versioned, JSON-safe definition of steps, variables, conditions, loops, tools, outputs, and limits.

02

Agent Run Manifest

A small invocation contract that references an agent and supplies validated runtime variable overrides.

03

Host Configuration

Model providers, credentials, connections, persistence, compute, sandboxes, and telemetry remain under host control.

Included capabilities

A reliable foundation for multi-step agents.

Manifest graph execution

Resolve declarative steps and variable dependencies into a deterministic execution plan with safe fan-out and fan-in.

Model choice

OpenAI, Anthropic, Google, xAI, Groq, Cohere, and OpenAI-compatible endpoints through the AI SDK adapter.

Tools and MCP

Application tools and MCP connections with host-defined credentials, modes, aliases, and tool allowlists.

Native authorization

Credential resolution, connection modes, tool allowlists, read/write narrowing, and host authorization hooks are enforced by the runtime.

Durable state

Typed variables, checkpoints, resumable loops and sub-runs, manifest verification, and fenced execution attempts.

Streaming and events

Ordered lifecycle, model, tool, checkpoint, artifact, and text-delta events for CLIs, applications, and telemetry.

Native sandboxing and artifacts

Sandbox contracts and artifact handling are built into the runtime, with Docker and Modal providers and a custom adapter interface.

Execution adapters

Run the same Agent Manifest across execution environments.

Execution adapters provide a consistent interface for submission, status, ordered events, results, resume, and cancellation. Move between local, child-process, and remote execution without changing the Agent Manifest.

Agent ManifestPortable definition
Agent RuntimeState, events, and adapters
Local processRun directly in an application or through the CLI.
Child processUse the portable worker protocol as a clean process boundary.
Remote computeDispatch through Modal or another execution-engine adapter.

Agent Run Manifest

Supply only the values this run needs.

Runtime variables must match declarations in the Agent Manifest. A run can override a default, satisfy a required input, or leave the agent-level value unchanged. It cannot introduce undeclared variables.

release-brief.run.yaml
schemaVersion: '1.0'
agent:
  ref: ./release-brief.agent.yaml

variables:
  - key: topic
    value: Agent Runtime public release
  - key: audience
    value: developers

Reliability and boundaries

Predictable execution is the default.

Explicit state transitions, bounded operations, and recoverable execution make agent behavior easier to understand and operate.

  • A step commits before the next state-mutating step begins.
  • Tool calls execute in order so state changes remain predictable.
  • Checkpoints preserve state, step outputs, transcripts, generated files, and continuation data.
  • Attempt fencing prevents an older worker from committing after a resumed attempt takes ownership.
  • Event cursors combine attempt and sequence for reconnectable remote streams.
  • Manifests cannot grant themselves credentials, infrastructure access, or broader tool permissions.

Release status

What the public release includes

Version 0.1.0 is available from npm without a source build, alongside the CLI, worker protocol, adapters, documentation, tests, and interactive examples.

Install from npm View the source
  • Versioned Agent Manifest and Agent Run Manifest contracts
  • Ready-to-install npm packages, CLI, worker protocol, and interactive examples
  • Native authorization policy, sandbox contracts, durable state, and execution engines
  • Local, SQLite, Modal, Docker, AI SDK, MCP, generated-file, and OpenTelemetry adapters
  • Developer documentation for embedding, streaming, recovery, connections, and custom adapters
  • Apache-2.0 licensing, contribution guidance, security policy, and compatibility policy

Standalone by design

Run it independently.

Clear Ideas Agent Runtime is a standalone open-source project for developers building agent execution into their own applications and infrastructure. Hosted Clear Ideas uses the same runtime foundation for Clear Ideas Agents, but it is not required to install, configure, or operate the runtime.