Skip to main content

71 docs tagged with "WG"

Working group notes, feature specs, and implementation plans.

View all tags

ACP Integration

An ACP-first client boundary with custom presentation, explicit capabilities, and durable execution semantics.

ACP Provider: Codex

Provider profile for consuming Codex from an external agent system. Defines what Codex provides, how a host should adapt it into an ACP-consuming runtime, and the boundaries around tools, sessions, filesystem authority, and image generation.

ACP Provider: the agent-provider class (ACP consumer)

Decision/RFD on whether Grida should host an agent-provider class — driving an external ACP agent (Claude Code / Codex) the user already pays for, with Grida as ACP consumer and an MCP server of its own tools. The forever-cost ledger, the narrow delta over BYOK, and a reversible path.

Agent Components

Component boundaries for messages, inference, tools, history, context, live execution, and durable sessions, with explicit dependencies and independently testable contracts.

Agent Experience

The agent's user experience contract, including agent effort, planning, progress, control, recovery, and a final summary of every turn.

Agent Hooks

Configurable lifecycle automation with explicit decision points, scoped execution, and recoverable outcomes.

Agent Master

The product harness that turns reusable agent components into intentional behavior, controls task performance, and fulfills the user experience contract.

Agent security

Desktop binding of GRIDA-SEC-004 and GRIDA-SEC-008 for ServicesSidecar, the renderer bridge, HTTP perimeter, sandbox, native provider OAuth, and secrets discipline.

Agent storage layout

Which Desktop process keeps which files — the native agent host's chat state and the retained sidecar's registries and credentials.

Agent System (WG)

The agent system's behavior, product policy, and agnostic execution component contracts.

AI (WG)

Agent design proposals, user expectations, reusable execution contracts, and existing Grida integration studies.

Billing (WG)

Platform billing ownership and the retained Grida integration and commercial contracts.

Billing known issues

Retained billing issue identities, original history, and Platform or Grida producer ownership.

Binary file handling

Glossary and reference for how an agent handles binary attachments the model cannot natively read. Three resolution paths (provider-native multimodal, skill-per-format, shell-based conversion), a format matrix, the scratch-space pattern for archive extraction, and the boundary between protocol and implementor.

Built-in subagents

Grida's specialized internal agents (chat titles and context compaction) — concrete bindings of the specialized-subagent pattern with their provider and cost discipline.

Canvas Tools (for AI)

Canvas-specific AI toolset for editing Grida design documents — scene-graph operations, specialized inserts, canvas exec/lint/format, and resource lookup.

CLI credential custody

Grida account session custody and the accepted shared TOML storage design for local provider API keys.

CLI documentation

Home, publishing contract, and lightweight maintenance checks for Grida CLI user documentation.

Clipboard — copy, cut, paste

FRD for clipboard support in the SVG editor: the payload is a standalone SVG document, not a private format. Specifies the two extraction operations (standalone payload vs in-document clone), the five kinds of context a lifted subtree leaves behind and the policy for each, command and history semantics, placement, transport ownership, and the paste-is-load trust model.

Compositor

How a person's intent is represented and lowered. The structured parts of submitted input, references versus attachments and the routing policy between them, directory references, commands, mentions, editor context, attachment classes, and the rules that turn what a person composes into what the model receives.

Cost Optimization

Doctrine for running frontier models in an agent loop without paying for waste. The loop's cost model (every token is re-sent every step, at one of several price tiers), the recurring failure classes — missing prompt caching, tool results that echo their input, unbounded and stale tool output, window and compaction decided apart from pricing, rewrite-heavy revision, an unaudited baseline — and the quality-first order for addressing them.

Desktop (WG)

Grida Desktop is one host implementation of the agent RFC. These docs are delta-only — every fact here depends on the Electron + macOS/Linux/Windows host shape.

Desktop agent authority

The Desktop delta for host containment, native host networking, and confined raw agent execution.

Docs sources (WG)

How one docs site publishes docs that are authored in other repositories — who owns the page and its assets, who owns the version, and what each side must honor.

Durable node identity — referencing a node across reloads and rewrites

RFD for the open problem behind #775: NodeId is parse-ephemeral, so there is no reference that survives a load() — let alone an external rewrite of the file. Frames the gap, scopes the candidate identity contracts (positional path, id attribute, semantic anchor), and sets the promotion gate before any public API lands.

Execution authority

This document decides where an agent host applies confinement. The boundary is

Fundamental Tools (Grida binding)

How the locked fundamental-tool RFC lands in Grida. Naming map (RFC id → Grida id), backend adapter table, per-tool deviations Grida ships, and where each tool lives in the monorepo.

Grida bindings

Grida-specific tool surfaces and bindings of the agent RFC. Fundamentals as Grida ships them, canvas tools (scene-graph search, specialized inserts, exec/lint/format, resource lookup), and image-generation tools.

Grida CLI — doctrine

A local command interface for Grida, with independent product capabilities and a shared contract for people, scripts, and future MCP clients.

Grida CLI v1

First-release contract for Grida CLI — expose Grida Desktop's account access and AI tools through an independently usable command interface.

Grida Gateway (GG)

Grida Gateway (GG) — how an untrusted native client runs Grida-hosted AI without its own API key via scoped-token federation, a first-party metered gateway, and server-side entitlement.

Grida Library (WG)

A curated corpus of openly-licensed visual assets, and the model by which

Hit-testing — design notes for v2

Investigation, bugs, and architectural lessons from a v1 hit-test implementation in @grida/svg-editor — input to the v2 hit-test architecture.

Image insertion — resolvable href, host-owned I/O

FRD for inserting <image> elements into the SVG editor. The editor accepts an image insertion at a point given a resolvable href and host-supplied intrinsic size; turning a local file into a usable URL, and loading bytes to learn a natural size, are host-owned I/O. Specifies the insertion contract, the responsibility boundary, drop/paste transport ownership, href authoring, and the P1 round-trip guarantee for the inserted element.

Image Tools (for AI)

This document proposes the philosophical basis for image manipulation tools that enable AI agents to generate, enhance, and transform visual content within the design canvas.

Lifecycle Events

Session-scoped lifecycle facts, their delivery and ordering, and how a host uses them for background attention.

Local Daemon

The agent server as a long-lived, discoverable local process — one server, many clients. The discovery contract (registration record, persistent credential, atomic publish, single-daemon convergence), the authenticated probe and protocol gate, connect-or-spawn, the browser exception, and the production shape.

MCP and Connectors

MCP consumption and Grida capability export, with shared tool contracts, bounded discovery, credential handling, and explicit recovery.

Permission policy

How an agent host decides whether an action runs, asks, or is refused — effects declared by tools, a policy of sandbox level, approval mode and reviewer, named presets, defaults, and configuration as a file.

Plan Mode

The Plan operating regime as a host-owned property of each accepted input. The regime pair, the transition invariants (the host owns the regime, the agent recommends but never effects a change, a person authorizes execution, the plan is reviewed before Act), capability-layer enforcement, and the narrow plan-artifact carve-out.

Platform (WG)

Working group documents for Grida platform and infrastructure topics.

Process model

Why Grida Desktop runs the native agent host and a retained media sidecar beside Electron main, what each owns, and where the boundaries sit.

Promote-to-Path — vector editing of non-path shapes

RFD for editing the non-path SVG shapes (rect, circle, ellipse, line, polyline, polygon) as vector geometry: native writeback while the tag can express the edit, promotion to <path> when it cannot — the timing, target, conic representation, and round-trip invariants that keep the conversion honest.

Renderer bridge

Why Grida Desktop URL-loads grida.co/desktop/* instead of bundling editor source — the "one editor codebase, two hosts" doctrine and the path-scoped window.grida bridge.

Rendering hardening — the inert projection

Specification for rendering untrusted SVG documents inertly in the SVG editor: hardening is a projection choice at the rendering surface, never a mutation of the document model. Names the execution-vector inventory the projection must neutralize, the surface obligations that constrain the strategy, the inert-projection requirements, the named costs, and the residual risks left to the host.

Resource loading

How the desktop renderer obtains host-owned resource bytes (workspace files — text, images, video) — the buffered-vs-streamed transport model, the privileged media scheme, and why the host proxies rather than handing the renderer or main process its own file authority.

Runtime Environments

The three environments an agent can be hosted in — web (a browser page), cloud sandbox (an ephemeral container or virtual machine), and computer (the user's machine) — and which capabilities, enforcement, and persistence each can honestly offer.

Scratch Storage

Host-managed working storage for staged inputs, temporary outputs, and recoverable agent work, separate from authored project files.

Subtree clone — duplicate and clone-drag

Design note for the SVG editor's in-document subtree-clone operation: the second of the clipboard FRD's two extraction operations. Specifies the no-closure/no-shell verdict, verbatim-id collision semantics, placement and paint order, who moves during a clone-drag, the mid-drag modifier toggle, the one-undo-step history bracket, and the repeating-offset duplicate (⌘D remembers the translate delta).

SVG Editor (TS SDK) — Design

Index of design notes for the @grida/svg-editor TypeScript SDK — element IR proposal, hit-test architecture, transform pipeline critique, Policy Class glossary.

Text creation — design

Why creating text in an SVG editor is click-to-place rather than drag-to-size, and why an empty text element is treated as a deletion.

Tool Design

The design discipline for shaping an agent tool before it is written — the doctrine behind the tool contract. A tool is a contract authored for a consumer that cannot be renegotiated with and cannot be migrated. Minimal surface, host config off the arguments, grounded and honest knobs, auto-resolved inputs, context-frugal and clearly-failing results, and when to reach for a tool versus a connector versus a skill.

Tools

Shared invocation semantics and product-owned tool profiles, authority, results, and presentation.

Triggers

What may start or resume work besides a person submitting input — scheduled wake-ups today, and the requirements any external source (configured schedules, webhooks, programmatic calls, protocol notifications) must meet before it can. Origin provenance, admission through the ordinary queue, trust, headless approval, and lifetime bounds.

Turn Authority

The host states which accepted input each turn serves and what became of it; a client renders those facts and never reconstructs them from its own pending view. The authority direction, the identities and transitions a client reads, and how optimistic presentation reconciles.

Vertex Transform Box — transform a vector sub-selection

Spec for the Vertex Transform Box: treating a multi-vertex sub-selection in path-edit as a single transformable object (translate / scale / rotate via one affine), the interaction model, the session-persistent frame, the policy, and the design questions deferred.

Visual perception

The read/view modality split. Why a text read and a visual view are separate tools, the perception-tool contract, the input matrix (bitmaps now, rendered sources later), how a tool result becomes a provider image block, and the retention policy that keeps perceived pixels from re-filling context every turn.

Workspace surfaces

The current Grida product contract for repository-backed workspaces, visible artifacts, canvas-first agent behavior, and auxiliary surface presentation.

Workspaces and Project Directories

A resolved workspace binds named directory identities and a primary directory to agent work while keeping membership, authority, and scratch separate.