Configuration Reference

Complete reference for all Signet configuration options. For initial setup, see Quickstart. For the Daemon runtime, see Architecture.

Configuration Files

All files live in your active Signet workspace.

• Default workspace: ~/.agents/
• Persisted workspace setting: ~/.config/signet/workspace.json
• Override for a single process: SIGNET_PATH=/some/path

The loader checks agent.yaml, AGENT.yaml, and config.yaml in that order, using the first file it finds. All sections are optional; omitting a section falls back to the documented defaults.

Workspace selection and persistence

Use the CLI to inspect or change the default workspace path:

signet workspace status
signet workspace set ~/.openclaw/workspace

signet workspace set is idempotent. It safely migrates files, stores the new default workspace in ~/.config/signet/workspace.json, and updates detected OpenClaw-family configs to keep agents.defaults.workspace aligned.

Resolution order for the effective workspace is:

1. --path CLI option
2. SIGNET_PATH environment variable
3. Stored CLI workspace setting (~/.config/signet/workspace.json)
4. Default ~/.agents/

agent.yaml

The primary configuration file. Created by signet setup and editable via signet configure or the dashboard’s config editor.

version: 1
schema: signet/v1

agent:
  name: "My Agent"
  description: "Personal AI assistant"
  created: "2025-02-17T00:00:00Z"
  updated: "2025-02-17T00:00:00Z"

owner:
  address: "0x..."
  localId: "user123"
  ens: "user.eth"
  name: "User Name"

harnesses:
  - forge
  - claude-code
  - openclaw
  - opencode

embedding:
  provider: ollama
  model: nomic-embed-text
  dimensions: 768
  base_url: http://localhost:11434
  promptSubmitTimeoutMs: 1000

search:
  alpha: 0.7
  top_k: 20
  min_score: 0.3

memory:
  database: memory/memories.db
  session_budget: 2000
  decay_rate: 0.95
  synthesis:
    harness: openclaw
    model: sonnet
    schedule: daily
    max_tokens: 4000
  pipelineV2:
    enabled: true
    shadowMode: false
    extraction:
      provider: llama-cpp
      model: qwen3:4b
    synthesis:
      enabled: true
      provider: ollama
      model: qwen3:4b
    graph:
      enabled: true
    autonomous:
      enabled: true
      maintenanceMode: execute

identity:
  preset: minimal
  startup:
    load:
      - path: AGENTS.md
        role: operating_instructions
        budget: 12000
  special:
    - path: DREAMING.md
      kind: dreaming
      role: dreaming_prompt
      budget: 4000

hooks:
  sessionStart:
    recallLimit: 10
    includeIdentity: true
    includeRecentContext: true
    recencyBias: 0.7
  userPromptSubmit:
    enabled: true
    recallLimit: 10
    maxInjectChars: 500
    minScore: 0.8
  preCompaction:
    includeRecentMemories: true
    memoryLimit: 5

auth:
  mode: local
  defaultTokenTtlSeconds: 604800
  sessionTokenTtlSeconds: 86400

trust:
  verification: none

agent

Core agent identity metadata.

owner

Optional owner identification. Reserved for future cryptographic identity verification.

harnesses

List of AI platforms to integrate with. Valid values: forge, claude-code, opencode, openclaw, and codex. Support for cursor, windsurf, chatgpt, and gemini is planned.

embedding

Vector embedding configuration for semantic memory search.

Increase promptSubmitTimeoutMs when local embedding models are slow to cold-load. For example, Ollama with mxbai-embed-large may need 10000 ms to avoid aborted prompt-submit recall embeddings.

Recommended Ollama models:

Recommended OpenAI models:

Rather than putting an API key in plain text, store it with signet secret put OPENAI_API_KEY and reference it as:

api_key: $secret:OPENAI_API_KEY

search

Hybrid search tuning. Controls the blend between semantic (vector) and keyword (BM25) retrieval.

At alpha: 0.9 results are heavily semantic, suitable for conceptual queries. At alpha: 0.3 results skew toward keyword matching, better for exact-phrase lookups. The default of 0.7 works well generally.

memory

Memory system settings.

Non-pinned memories lose importance over time using the formula:

importance(t) = base_importance × decay_rate^days_since_access

Accessing a memory resets the decay timer.

identity

Identity loading is configurable. Presets choose which Markdown files load into normal startup context and which files are reserved for special sessions.

Built-in presets:

• minimal — startup loads only AGENTS.md; DREAMING.md is still created and available for dreaming sessions, but is not loaded every turn.
• hermes — startup loads SOUL.md then AGENTS.md, matching Hermes’ current SOUL-primary identity plus project-context convention.
• openclaw — rich startup stack: AGENTS.md, SOUL.md, IDENTITY.md, USER.md, and MEMORY.md, with HEARTBEAT.md, DREAMING.md, and BOOTSTRAP.md reserved as special-session prompts.
• custom — explicit ordered startup list chosen by the user.

Example custom order:

identity:
  preset: custom
  startup:
    load:
      - path: USER.md
        role: user_profile
        budget: 6000
      - path: AGENTS.md
        role: operating_instructions
        budget: 12000
  special:
    - path: DREAMING.md
      kind: dreaming
      role: dreaming_prompt
      budget: 4000

Special session files are not startup context. DREAMING.md is the prompt for reflection/consolidation runs and costs zero tokens in ordinary sessions.

memory.synthesis

Configuration for periodic MEMORY.md regeneration. The synthesis process reads all memories and asks a model to write a coherent summary.

Inference

Signet’s shared inference control plane is configured under the top-level inference key in agent.yaml.

If inference is omitted, Signet preserves the old behavior by compiling memory.pipelineV2.extraction and memory.pipelineV2.synthesis into an implicit inference profile. That keeps existing agents working without change.

Use inference when you want Signet to choose models across harnesses, accounts, APIs, and local runtimes per turn or per subtask.

Example:

inference:
  enabled: true
  defaultPolicy: auto

  accounts:
    claude-dot:
      kind: subscription_session
      providerFamily: anthropic
      label: Dot Claude Connected
      sessionRef: CLAUDE_DOT_SESSION
    openrouter-main:
      kind: api
      providerFamily: openrouter
      credentialRef: OPENROUTER_API_KEY

  targets:
    opus:
      executor: claude-code
      account: claude-dot
      models:
        opus46:
          model: opus-4.6
          reasoning: high
          toolUse: true
          streaming: true
    sonnet:
      executor: openrouter
      account: openrouter-main
      privacy: remote_ok
      endpoint: https://openrouter.ai/api/v1
      models:
        default:
          model: anthropic/claude-sonnet-4-6
          reasoning: medium
          toolUse: true
          streaming: true
          costTier: medium
    local:
      executor: ollama
      endpoint: http://127.0.0.1:11434
      privacy: local_only
      models:
        gemma4:
          model: gemma4
          reasoning: medium
          streaming: true
          costTier: low

  policies:
    auto:
      mode: automatic
      defaultTargets:
        - opus/opus46
        - sonnet/default
        - local/gemma4

  taskClasses:
    casual_chat:
      reasoning: medium
      preferredTargets:
        - sonnet/default
    hard_coding:
      reasoning: high
      toolsRequired: true
      preferredTargets:
        - opus/opus46
    hipaa_sensitive:
      privacy: local_only
      preferredTargets:
        - local/gemma4

  workloads:
    interactive:
      policy: auto
      taskClass: casual_chat
    memoryExtraction:
      policy: auto
      taskClass: casual_chat
    sessionSynthesis:
      policy: auto
      taskClass: casual_chat

  agents:
    rose:
      defaultPolicy: auto
      roster:
        - opus/opus46
        - sonnet/default
        - local/gemma4
      pinnedTargets:
        hard_coding: opus/opus46

inference.accounts

Named account or credential identities used by targets.

inference.targets

Executable route targets. A target can be a local runtime, API backend, subscription-backed CLI session, or gateway.

Example ACPX background target (see also docs/ACP-INTEGRATION.md for the architecture and current limitations):

inference:
  targets:
    background-codex:
      executor: acpx
      agent: codex
      hooks: disabled
      terminal: false
      format: json
      captureEvents: true
      timeoutMs: 120000
      models:
        mini:
          model: gpt-5.4-mini
          reasoning: medium
          toolUse: true

Model fields:

inference.policies

Named routing policies that agents and workloads reference.

inference.taskClasses

Task-family hints for automatic routing.

inference.workloads

Binds Signet-owned workloads to router policies or explicit targets.

Supported workload keys:

• interactive
• memoryExtraction
• sessionSynthesis

Each workload can define:

inference.agents

Per-agent routing overrides.

Pipeline V2 Config

The V2 memory pipeline lives at platform/daemon/src/pipeline/. It runs LLM-based fact extraction against incoming conversation text, then decides whether to write new memories, update existing ones, or skip. Config lives under memory.pipelineV2 in agent.yaml.

Inference selection for extraction and session synthesis can also be routed through the top-level inference.workloads bindings. When explicit routing is enabled for default, memoryExtraction, sessionSynthesis, widgetGeneration, or repair, those workloads use the shared inference control plane. Legacy extraction and synthesis fields are treated as load-time compatibility input, not separate runtime providers.

The config uses a nested structure with grouped sub-objects. Legacy flat keys (e.g. extractionModel, workerPollMs) are still supported for backward compatibility, but nested keys take precedence when both are present.

Enable the pipeline:

memory:
  pipelineV2:
    enabled: true
    shadowMode: true        # extract without writing — safe first step
    extraction:
      provider: llama-cpp
      model: qwen3:4b

Control flags

These top-level boolean fields gate major pipeline behaviors.

The relationship between shadowMode and mutationsFrozen matters: shadowMode suppresses writes from the normal extraction path only; mutationsFrozen is a harder freeze that blocks all write paths including repairs and graph updates.

Extraction (extraction)

Controls the LLM-based extraction stage. Supports multiple providers.

For safety, the intended extraction setups are:

• local llama-cpp with qwen3:4b (default)
• claude-code on a Haiku model
• codex on a gpt-5.4-mini model
• local ollama with nemotron-3-nano:4b (preferred) or qwen3:4b (deprecated — Nemotron’s superior reasoning makes Qwen3 the weaker choice going forward; expect degraded extraction quality in future updates)

Set provider: none to disable extraction entirely, which is the recommended default for VPS installs that should not make background LLM calls.

Remote API extraction can accumulate extreme fees quickly because the pipeline runs continuously in the background. Use anthropic, openrouter, or remote OpenCode routes only when you explicitly want that billing behavior.

rateLimit is opt-in. If the stanza is omitted, Signet preserves the provider’s existing behavior with no throughput throttling. When configured, it applies only to remote or paid providers (acpx, claude-code, anthropic, openrouter, codex, opencode). Ollama and command providers are always exempt. If you set rateLimit on an exempt provider, Signet logs a warning and passes calls through unthrottled.

An empty rateLimit: {} block is treated as disabled. Set at least one sub-field to opt in, or omit the stanza entirely to leave rate limiting off.

When a rate-limited job fails (the bucket is empty and the wait timeout expires), it is classified as non-retryable and sent directly to dead-letter status. Dead-lettered jobs are not retried when the rate-limit window resets. Choose maxCallsPerHour high enough to handle sustained ingestion bursts, or you will permanently lose extraction for memories queued during exhaustion. Dead-letter jobs are purged after 30 days by the retention worker.

When configured via YAML, burstSize is clamped to a minimum of 1. The lower-level withRateLimit() helper is more defensive: passing burstSize: 0 or maxCallsPerHour: 0 disables the wrapper entirely instead of constructing a limiter that can never acquire a token.

Rate-limiter state is in-memory only. After a daemon restart the full burstSize is available immediately (the token bucket starts full). In environments with frequent restarts (crash-loops, rolling deployments), this means the limiter cannot protect against a burst of calls right after startup. Set burstSize conservatively if your daemon restarts often under load.

When using ollama, the model must be available locally. When using claude-code, the Claude Code CLI must be on PATH. codex uses the Codex CLI as the extraction provider. Lower minConfidence to capture more facts at the cost of noise; raise it to write only high-confidence facts.

acpx is available as a setup compatibility value for installations that also have a top-level inference: block. ACPX needs harness/session config, so legacy memory.pipelineV2.extraction.provider: acpx by itself is not compiled into an implicit legacy-extraction target; keep the generated inference.targets.*.executor: acpx block or configure ACPX through top-level inference routing.

There are two command paths with different contracts. Top-level inference.targets.*.executor: command is a normal inference provider: the prompt is sent on stdin, exposed as SIGNET_PROMPT, and the model response is read from stdout.

Legacy memory.pipelineV2.extraction.provider: command keeps the old side-effecting extractor contract. The summary worker executes memory.pipelineV2.extraction.command, writes the transcript to a temporary file, substitutes that path into args/env, and expects the command to write memories to Signet state directly. Stdout and stderr are ignored except for process failure.

Available legacy extraction command tokens:

• $TRANSCRIPT (alias $TRANSCRIPT_PATH) — temp transcript file path
• $SESSION_KEY — session key (or empty string)
• $PROJECT — project path (or empty string)
• $AGENT_ID — agent id for the queued job
• $SIGNET_PATH — active Signet workspace path

For safety, user-derived tokens ($SESSION_KEY, $PROJECT, $TRANSCRIPT) are intended for args/env substitution. Keep bin and cwd fixed, or use only trusted $SIGNET_PATH / $AGENT_ID there.

Example:

memory:
  pipelineV2:
    extraction:
      provider: command
      command:
        bin: node
        args:
          - ./scripts/custom-extractor.mjs
          - --transcript
          - $TRANSCRIPT
          - --session
          - $SESSION_KEY

Session synthesis (synthesis)

Controls the provider used by the summary-worker for session summaries. This is separate from fact extraction once explicitly configured.

If the synthesis block is omitted entirely, Signet falls back to the resolved extraction provider, model, endpoint, and timeout. When an explicit top-level inference: block exists, workload bindings decide which target handles synthesis.

Set provider: none or enabled: false to disable background session summary synthesis entirely.

synthesis.provider: command is invalid and rejected during config load.

Widget HTML generation uses a separate provider instance by default, so widget traffic does not consume the synthesis pipeline’s rateLimit bucket.

As with extraction, an empty rateLimit: {} block is treated as disabled. Set at least one sub-field to opt in.

Rate-limited synthesis jobs that fail are sent to dead-letter without retry. See the extraction rateLimit docs above for the full warning.

Worker (worker)

The pipeline processes jobs through a queue with lease-based concurrency control.

A job that exceeds maxRetries moves to dead-letter status and is eventually purged by the retention worker. Legacy flat keys workerMaxLoadPerCpu and workerOverloadBackoffMs are still accepted for backward compatibility.

Knowledge Graph (graph)

When graph.enabled: true, the pipeline builds entity-relationship links from extracted facts and uses them to boost search relevance.

Structural Analysis (structural)

Structural workers classify extracted facts into entity aspects, extract direct entity dependencies from facts, and synthesize cross-entity dependency edges from the existing graph.

The aliases dependencySynthesis.maxStallMs and dependencySynthesis.synthesisMaxStallMs are accepted for structural.synthesisMaxStallMs.

Hints (hints)

Prospective indexing generates hypothetical future queries at write time. These “hints” are indexed in FTS5 so memories match by anticipated cue, not just stored content. For example, a memory about “switched from PostgreSQL to SQLite” might generate hints like “database migration”, “why SQLite”, and “storage engine decision” — queries the user is likely to ask later.

memory:
  pipelineV2:
    hints:
      enabled: true
      max: 5
      timeout: 30000
      maxTokens: 256
      poll: 5000

Traversal (traversal)

Graph traversal controls how the knowledge graph is walked during retrieval. When primary: true, graph traversal produces the base candidate pool and flat search fills gaps. When primary: false, traditional hybrid search runs first with graph boost as supplementary.

memory:
  pipelineV2:
    traversal:
      enabled: true
      primary: true
      maxAspectsPerEntity: 10
      maxAttributesPerAspect: 20
      maxDependencyHops: 10
      minDependencyStrength: 0.3
      maxBranching: 4
      maxTraversalPaths: 50
      minConfidence: 0.5
      timeoutMs: 500
      boostWeight: 0.2
      constraintBudgetChars: 1000

The primary flag determines the retrieval strategy. In primary mode, entities are extracted from the query, the graph is walked to collect related memories, and flat hybrid search only runs to fill remaining slots. In supplementary mode (primary: false), the standard hybrid search runs first and traversal results are blended in using boostWeight. Primary mode is faster for entity-dense queries; supplementary mode is more conservative and better for freeform text.

Reranker (reranker)

An optional reranking pass that runs after initial retrieval. An embedding-based reranker is built in (uses cached vectors, no extra LLM calls). Optionally, reranking can call the active extraction provider model.

Autonomous (autonomous)

Controls autonomous maintenance, repair, and mutation behavior.

In "observe" mode the worker emits structured log events but makes no changes. When frozen is true, the maintenance interval never starts, though the worker’s tick() method remains callable for on-demand inspection.

Repair budgets (repair)

Repair sub-workers limit how aggressively they re-embed, re-queue, or deduplicate items to avoid overloading providers.

Document ingest (documents)

Controls chunking for ingesting large documents into the memory store.

Chunk overlap ensures context is not lost at chunk boundaries. A value of 10-15% of chunkSize is a reasonable starting point.

Guardrails (guardrails)

Content size limits applied during extraction and recall to prevent oversized content from degrading pipeline performance.

These limits are enforced at the pipeline level. Content exceeding maxContentChars is truncated before storage. Recall results are truncated at recallTruncateChars to keep session context budgets predictable.

Continuity (continuity)

Session checkpoint configuration for continuity recovery. Checkpoints capture periodic snapshots of session state (focus, prompts, memory activity) to aid recovery after context compaction or session restart.

Checkpoints are triggered by five events: periodic, pre_compaction, session_end, agent, and explicit. Secrets are redacted before storage.

Sub-agents (subagents)

Controls deterministic parent-session context inherited by sub-agent sessions at session-start. This uses stored active transcripts and checkpoints; it does not make an LLM call.

memory:
  pipelineV2:
    subagents:
      inheritContext: true
      tailChars: 3000

Set inheritContext: false to disable automatic inherited context while leaving the explicit session_search MCP/API surface available.

Telemetry (telemetry)

Anonymous usage telemetry. Only active when telemetryEnabled: true. Events are batched and flushed periodically.

memorySearchQaEnabled is separate from anonymous telemetry. It writes a local review ledger to SQLite and intentionally includes recall query text and recalled result content, so it is exposed only through analytics-gated endpoints and is never sent to PostHog.

Embedding tracker (embeddingTracker)

Background polling loop that detects stale or missing embeddings and refreshes them in small batches. Runs alongside the extraction pipeline.

The tracker detects embeddings that are missing, have a stale content hash, or were produced by a different model than the currently configured one. It uses setTimeout chains for natural backpressure.

Auth Config

Auth configuration lives under the auth key in agent.yaml. Signet uses short-lived signed tokens for dashboard and API access.

auth:
  mode: local
  defaultTokenTtlSeconds: 604800    # 7 days
  sessionTokenTtlSeconds: 86400     # 24 hours
  rateLimits:
    forget:
      windowMs: 60000
      max: 30
    modify:
      windowMs: 60000
      max: 60
    inferenceExplain:
      windowMs: 60000
      max: 120
    inferenceExecute:
      windowMs: 60000
      max: 20
    inferenceGateway:
      windowMs: 60000
      max: 30

In "local" mode the token secret is generated automatically and stored at $SIGNET_WORKSPACE/.daemon/auth-secret. In "team" and "hybrid" modes, the daemon validates HMAC-signed bearer tokens with role and scope claims.

Rate limits

Rate limits are sliding-window counters that reset on daemon restart. Each key controls a category of potentially destructive operations.

Override any limit under auth.rateLimits.<operation>:

auth:
  rateLimits:
    forceDelete:
      windowMs: 60000
      max: 1

Retention Config

The retention worker runs on a fixed interval and purges data that has exceeded its retention window. It is not directly configurable in agent.yaml; the defaults below are compiled in and apply unconditionally when the pipeline is running.

The retention worker also cleans up graph links and embeddings that belong to purged tombstones, and orphans entity nodes with no remaining mentions. The batchLimit prevents a single sweep from locking the database for too long under high load.

Soft-deleted memories remain recoverable via POST /api/memory/:id/recover until their tombstone window expires.

Hooks Config

Controls what Signet injects during harness lifecycle events. See Hooks for full details.

hooks:
  sessionStart:
    recallLimit: 10
    includeIdentity: true
    includeRecentContext: true
    recencyBias: 0.7
  userPromptSubmit:
    enabled: true
    recallLimit: 10
    maxInjectChars: 500
    minScore: 0.8
  preCompaction:
    includeRecentMemories: true
    memoryLimit: 5
    summaryGuidelines: "Focus on technical decisions."

hooks.sessionStart controls what is injected at the start of a new harness session:

Predicted context from recent session summaries is scoped to the active project. If the harness does not provide a project path, Signet skips predicted-context FTS at session start to avoid global broad-term scans over large memory stores.

hooks.preCompaction controls what is included when the harness triggers a pre-compaction summary:

hooks.userPromptSubmit controls per-prompt memory injection:

Environment Variables

Environment variables take precedence over agent.yaml for runtime overrides. They are useful in containerized or CI environments where editing the config file is impractical.

SIGNET_PATH changes where Signet reads and writes all agent data for that process, including the config file itself. Use this for temporary overrides in CI or isolated local testing.

On macOS, SIGNET_SQLITE_PATH can point at a libsqlite3.dylib build that supports loadExtension(). If it is set, Signet treats it as an authoritative override and refuses fallback if the file is missing. If it is unset, Signet checks $SIGNET_WORKSPACE/libsqlite3.dylib, where $SIGNET_WORKSPACE resolves from SIGNET_PATH, then ~/.config/signet/workspace.json, then the default ~/.agents, before trying standard Homebrew SQLite locations and finally falling back to Apple’s system SQLite.

For non-loopback Anthropic endpoint overrides, daemon-rs only sends provider credentials during startup preflight when the host is trusted. Official provider hosts are trusted by default. Add trusted proxy/gateway hosts through SIGNET_TRUSTED_PROVIDER_ENDPOINT_HOSTS.

AGENTS.md

The main agent identity file. Synced to all configured harnesses on change (2-second debounce). Write it in plain markdown — there is no required structure, but a typical layout looks like this:

# Agent Name

Short introduction paragraph.

## Personality

Communication style, tone, and approach.

## Instructions

Specific behaviors, preferences, and task guidance.

## Rules

Hard rules the agent must follow.

## Context

Background about the user and their work.

When AGENTS.md changes, the daemon writes updated copies to:

• ~/.claude/CLAUDE.md (if ~/.claude/ exists)
• ~/.config/opencode/AGENTS.md (if ~/.config/opencode/ exists)

Each copy is prefixed with a generated header identifying the source file and timestamp, and includes a warning not to edit the copy directly.

SOUL.md

Optional personality file for deeper character definition. Loaded by harnesses that support separate personality and instruction files.

# Soul

## Voice
How the agent speaks and writes.

## Values
What the agent prioritizes.

## Quirks
Unique personality characteristics.

MEMORY.md

Auto-generated working memory summary. Updated by the synthesis system. Do not edit by hand — changes will be overwritten on the next synthesis run. Loaded at session start when hooks.sessionStart.includeRecentContext is true.

Database Schema

The SQLite database at memory/memories.db contains three main tables.

memories

embeddings

memories_fts

FTS5 virtual table for keyword search over content, backed by the memories table and created with the unicode61 tokenizer. Triggers keep the index in sync when rows are inserted, deleted, or updated.

Harness-Specific Configuration

Claude Code

Location: ~/.claude/

settings.json installs hooks that fire at session lifecycle events:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "python3 $SIGNET_WORKSPACE/memory/scripts/memory.py load --mode session-start",
        "timeout": 3000
      }]
    }],
    "UserPromptSubmit": [{
      "hooks": [{
        "type": "command",
        "command": "python3 $SIGNET_WORKSPACE/memory/scripts/memory.py load --mode prompt",
        "timeout": 2000
      }]
    }],
    "SessionEnd": [{
      "hooks": [{
        "type": "command",
        "command": "python3 $SIGNET_WORKSPACE/memory/scripts/memory.py save --mode auto",
        "timeout": 10000
      }]
    }]
  }
}

OpenCode

Location: ~/.config/opencode/plugins/

signet.mjs is a bundled OpenCode plugin installed by @signet/connector-opencode that exposes /remember and /recall as native tools within the harness.

Note: Legacy memory.mjs installations are automatically migrated to ~/.config/opencode/plugins/signet.mjs on reconnect.

OpenClaw

Location: $SIGNET_WORKSPACE/hooks/agent-memory/ (hook directory)

Also configures the OpenClaw workspace in ~/.openclaw/openclaw.json (and compatible clawdbot / moltbot config locations):

{
  "agents": {
    "defaults": {
      "workspace": "$SIGNET_WORKSPACE"
    }
  }
}

See HARNESSES.md for the full OpenClaw adapter docs.

Git Integration

If your Signet workspace is a git repository, the daemon auto-commits file changes with a 5-second debounce after the last detected change. Commit messages use the format YYYY-MM-DDTHH-MM-SS_auto_<filename>. The setup wizard offers to initialize git on first run and creates a backup commit before making any changes.

Recommended .gitignore for your workspace:

.daemon/
.secrets/
__pycache__/
*.pyc
*.log