ACP Integration
An ACP-first client boundary with custom presentation, explicit capabilities, and durable execution semantics.
Working group notes, feature specs, and implementation plans.
View all tagsAn ACP-first client boundary with custom presentation, explicit capabilities, and durable execution semantics.
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.
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.
Component boundaries for messages, inference, tools, history, context, live execution, and durable sessions, with explicit dependencies and independently testable contracts.
The agent's user experience contract, including agent effort, planning, progress, control, recovery, and a final summary of every turn.
Configurable lifecycle automation with explicit decision points, scoped execution, and recoverable outcomes.
The product harness that turns reusable agent components into intentional behavior, controls task performance, and fulfills the user experience contract.
Desktop binding of GRIDA-SEC-004 and GRIDA-SEC-008 for ServicesSidecar, the renderer bridge, HTTP perimeter, sandbox, native provider OAuth, and secrets discipline.
Which Desktop process keeps which files — the native agent host's chat state and the retained sidecar's registries and credentials.
The agent system's behavior, product policy, and agnostic execution component contracts.
Agent design proposals, user expectations, reusable execution contracts, and existing Grida integration studies.
Platform owns native AI credit; Grida retains verified product execution and durable usage receipts.
Immediate model discovery and media generation from Desktop's existing capabilities, with planned provider-native execution beyond Grida's catalogue.
How Grida composes its local agent system — the native agent host, the retained media sidecar, and Desktop — and which process owns which authority.
Platform billing ownership and the retained Grida integration and commercial contracts.
Retained billing issue identities, original history, and Platform or Grida producer ownership.
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.
Grida's specialized internal agents (chat titles and context compaction) — concrete bindings of the specialized-subagent pattern with their provider and cost discipline.
Canvas-specific AI toolset for editing Grida design documents — scene-graph operations, specialized inserts, canvas exec/lint/format, and resource lookup.
Normative contract for using an eligible ChatGPT account as native Grida model capacity while Grida retains ownership of the agent loop, tools, and sessions.
Grida account session custody and the accepted shared TOML storage design for local provider API keys.
Home, publishing contract, and lightweight maintenance checks for Grida CLI user documentation.
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.
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.
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.
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.
The Desktop delta for host containment, native host networking, and confined raw agent execution.
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.
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.
Proposal for a typed per-node element IR that replaces tag-switch intent dispatch in @grida/svg-editor with capability-gated records, centralising round-trip invariants.
This document decides where an agent host applies confinement. The boundary is
Implementation details behind importing .fig files into Grida.
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-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.
A local command interface for Grida, with independent product capabilities and a shared contract for people, scripts, and future MCP clients.
First-release contract for Grida CLI — expose Grida Desktop's account access and AI tools through an independently usable command interface.
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.
A curated corpus of openly-licensed visual assets, and the model by which
Investigation, bugs, and architectural lessons from a v1 hit-test implementation in @grida/svg-editor — input to the v2 hit-test architecture.
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.
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.
Overview
Session-scoped lifecycle facts, their delivery and ordering, and how a host uses them for background attention.
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 consumption and Grida capability export, with shared tool contracts, bounded discovery, credential handling, and explicit recovery.
| feature id | status | description | PRs |
Independent Grida login, member-scoped account and credit reads, and shared GG access for native clients.
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.
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.
Working group documents for Grida platform and infrastructure topics.
Why Grida Desktop runs the native agent host and a retained media sidecar beside Electron main, what each owns, and where the boundaries sit.
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.
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.
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.
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.
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.
Host-managed working storage for staged inputs, temporary outputs, and recoverable agent work, separate from authored project files.
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).
Index of design notes for the @grida/svg-editor TypeScript SDK — element IR proposal, hit-test architecture, transform pipeline critique, Policy Class glossary.
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.
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.
Shared invocation semantics and product-owned tool profiles, authority, results, and presentation.
Context dump on the transform pipeline in @grida/svg-editor — what's done, what's broken, what's load-bearing for the IR redesign.
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.
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.
Summary
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.
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.
Welcome to the Grida Working Group documentation!
The current Grida product contract for repository-backed workspaces, visible artifacts, canvas-first agent behavior, and auxiliary surface presentation.
A resolved workspace binds named directory identities and a primary directory to agent work while keeping membership, authority, and scratch separate.