Fabric Studio

Compose agents
visually.

Fabric Studio is the standalone visual composer where production experts design, inspect, test and package agents in domain language — no hand-editing JSON. The suite contains two independent apps: Studio authors local drafts and signed packages; Fabric owns installation, trust, commissioning and execution authority.

Fabric Studio — node canvas, palette and inspector
1

Layout

The Studio interface

Node palette (left)

The capabilities you can add — Observe, Source, Transform, Validate, Decide, Approval, Publish and domain nodes — dynamically reflecting what the current runtime supports.

Canvas & pipeline spine

The agent as a graph: drag to add, connect stages, insert or delete nodes, and repair a broken flow. The spine shows execution order.

Inspector (right)

Per-node configuration: label, type, execution mode, inputs/outputs, policies, validators and evidence — tabbed and contract-aware.

2

Modes

Manual, AI & automatic execution

✋

Manual

A human performs the step; Fabric records it and hands off honestly. Used where no safe automated executor exists yet.

✦

AI-assisted

Fabric Intelligence performs the step through a real capability (vision QA, grounded drafting, reasoning), always grounded and confidence-scored.

⚙

Automatic

A deterministic executor runs the step (Photoshop JSX, Unity bridge, Perforce sync, data write) — only if the executor registry supports its mode and runtime.

“AI everywhere except sign-offs.”

AI is the default execution mode wherever a genuine capability exists — but it never fabricates success and never replaces the human approval gate. A step with no safe executor is an honest manual hand-off, not a faked “done”.

3

Workflow

Authoring an agent

1

Author with AI, start manually, or clone

Author with AI uses an installed local Ollama model to propose changes with cited references and clarification questions. Manual draft opens templates and a deterministic request form. Review and apply the exact proposal; Studio never auto-publishes it.

2

Configure nodes & connect stages

Choose registered capabilities, supported execution modes and meaningful inputs. Standalone Studio currently authors an ordered linear workflow; arbitrary DAG execution is not available here.

3

Lint & simulate

Contract checks and structural simulation explain draft readiness. Supported AI-authored phrase verifiers also run positive and negative disposable fixtures through the shared validator; this does not qualify the full workflow.

4

Save, sign and send

Save the local draft, export its signed package, or explicitly send it to a connected Executor. A newly authored draft is installed disabled and must pass Executor admission. Valid independently certified imports with satisfied dependencies can be ready for manual governed runs.

3a

Local intelligence

From conversation to a checked draft

1

Choose an installed model

Open Author with AI → Model setup, discover local Ollama models, select one and enable authoring. Studio does not download models or use cloud inference. Models that delegate to a remote service are rejected. Studio and Executor share local inference admission; 48 GB Macs need memory headroom for creative apps and sequential model use.

2

Add knowledge and accepted decisions

Knowledge accepts short SOPs, skills, examples and references. Local text matching retrieves relevant sources with fingerprints. Decisions stores explicit project choices; changed source references make a decision stale. This is separate from Executor run memory and RAG.

3

Describe, clarify and review

Select a saved draft, describe its inputs and intended outcome, then answer clarification questions. Studio permits at most two proposal attempts using canonical validation and supported fixture-test errors. Review field differences and explicitly apply; a stale saved revision is rejected.

4

Measure the model

Evaluations repeats requests against expected capabilities or clarification. Reports retain measured outcomes, timings and source references. They never apply drafts or certify workflow execution.

Fabric Intelligence authoring team.

Enable team review in Model setup for separate Requirements and Verification reviewers plus one relevant Architecture, Capability, Vision-planning or Recovery specialist. Up to three reviewers run sequentially. Context lookup, compilation and capability-gap requests remain shared services. Blockers prevent applying a proposal; these reviews never certify agent execution.

Local fallback and a compact workspace.

Select an optional fallback model for bounded inference or validation failures. Conversations show the actual model and specialist findings. Create → Check & test → Save & send stays visible; Advanced retains detailed readiness and secondary controls. Cancelling never applies a proposal.

3b

Standalone handoff

From Studio draft to Executor

Studio Drafts are private authoring state. They never load definitions from Pipeline-Repo, and connected Executor agents appear in a separate read-only catalogue. Clone an Executor definition when you want a new editable draft; the live installed definition is never edited in place.

1

Create or import a draft

Start blank, clone a read-only Executor agent, or use Import as Draft. Package import verifies the signed bytes and creates a unique editable copy without installing anything.

2

Check and test locally

Structural checks and no-write simulation expose unsupported capabilities and contract gaps without granting runtime authority.

3

Review the handoff

Send to Executor first shows the exact signed package digest and trust preview. Installation requires a separate confirmation.

4

Review and release in Executor

Executor binds the installed package to its exact revision, verifies any retained independent certification, and shows the next governed action. A new uncertified draft stays disabled/decommissioned; an eligible independently certified import may become ready for manual governed runs when its dependencies pass. Automatic routing, commissioning and production effects remain separate.

2026.9.91 streamlines the certified-agent release flow.

Release approvals are now server-owned and resume automatically after the server-side review is complete. The UI continues to distinguish handoff, package review, installation, certification review, release preparation and execution evidence as separate steps with separate evidence. Studio can author and sign a portable definition, but it cannot copy credentials, memory, commissioning state or execution authority into that package. A successful handoff is not a successful run.

4

Trust

Preview, validation & Executor gates

Preview verifies capability-to-executor coverage and shows proposed reads and writes. Studio simulation produces an explainable draft-readiness result without live writes. A high score never makes an unsupported or outward action safe: Executor policy, validation, approval, certification and commissioning gates remain binding.

The trust stack

Studio checks structure, package integrity and no-write behavior. Executor independently verifies the signature and compatibility, evaluates whether the import qualifies for manual runs, and applies its own capability, credential, approval and commissioning policy.

Intelligence Profiles & sealed skills

Intelligence Profiles v1.2.0 prove an agent's readiness across workspaces — resolved capabilities, installed/enabled knowledge, sealed runtime skill manifests, and required-tool readiness. Skills (48 from .claude/skills) follow a knowledge-vs-executable contract: RAG-ready guidance immediately, execution bound and sealed by version + digest at run start — no silent drift.

5

Reuse & recovery

Templates, components, versioning & troubleshooting

Templates & components

Start new agents from templates; reuse proven node groups as components. Treat a component like shared production code — narrow contracts, versioned changes, retest every consumer.

Versioning & diff

Saved draft versions provide visual diff and rollback, so every authoring change is reviewable and reversible before export.

Common issues

Flow breaks (use Repair flow), unsupported AUTO stages (pick a supported mode/executor), low source coverage (add grounding sources).

When authoring cannot compile a goal

Inspect the missing requirement or capability. The AI workspace can repair a proposal using concrete validation feedback; the manual request form is deterministic. Neither creates missing tool implementations. Provide authoritative inputs, revise the draft or implement and qualify the missing capability.

Clone before changing

Connected Executor agents are read-only in Studio. Clone one into a new local draft, review the differences, test without writes, then send a new signed version through Executor trust.

Retire legacy behavior only after proof

Check and test each replacement draft, then let Executor qualify it through its own governed lifecycle. Keep the previous installed version available until the replacement has passed that sequence.

6

Federation

Federated reuse & coordinated migration

Exporting a signed agent package lets another workstation import a credential-safe copy pinned to the exact authored version. Studio does not silently mutate installed copies; every replacement is a new package reviewed and accepted by Executor.

Explicit version migration

Dependency changes create a new draft and package. Installed agents stay pinned until an operator reviews and imports the replacement in Executor.

Governed contract remapping

If the upgrade changes the dependency's input/output contract, the upgrade is blocked until you map the boundary. Remap-preview auto-maps same-name, same-type fields and lists exactly which inputs and outputs still need an explicit mapping or default; the reviewed plan is digest-bound and travels with the draft.

Executor-owned certification

Studio never accepts caller-supplied certification or commissioning state. Executor verifies independent retained certification when present; commissioning and runtime effects remain locally governed.

Durable notifications & reconciliation

Consumers of a changed dependency receive retryable cross-workspace notices tracked in a durable delivery ledger: pending → delivered, or failed with bounded retry and dead-lettering after five attempts. Reconciliation re-attempts every outstanding notice, so a transient outage never drops a consumer.

Executor catalogue & portable packages

The connected Executor catalogue is read-only. Export a checksum-sealed forge.agent-package.v1 bundle containing the portable graph, profile metadata and permitted skills; credential-shaped fields and runtime authority are stripped.

Guided handoff

The standalone lifecycle is Build → Check → Test → Resolve → Save → Package → Executor. Executor then applies independent trust, certification and commissioning before any live run.

◇

Reference

Build → Check → Test → Resolve → Save → Package → Executor

  1. Build: start a draft, clone a read-only Executor definition, or use Import as Draft. Importing a signed package as a draft does not install it in Executor.
  2. Define the workflow graph in domain terms: inputs, stages, dependencies, outputs, validators, approval boundaries and required capabilities. Review node properties and edge order.
  3. Check: inspect schema validity, missing bindings, unsupported capabilities and proposed reads/writes. Resolve every required contract gap.
  4. Test: use the available simulation/draft tests and review their scope. A no-write simulation does not prove live provider success.
  5. Resolve: correct missing inputs, capability coverage and validation findings. Preserve exact intended outputs and approval boundaries.
  6. Save: retain the local draft as a new intended version. Changing an agent means its prior revision’s evidence cannot simply be relabeled.
  7. Package: export a signed .forge-agent package with an authorized signing setup. Do not embed credentials, private history or runtime state.
  8. Executor: explicitly send to a connected Executor when supported, or import the file there. Verify trust, compatibility, certification and commissioning before live use.
◇

Reference

Signing and certification

Studio’s developer signature attests to package bytes. Independent Fabric Intelligence certification is separate evidence for the exact workflow. Executor verifies any retained attestation and applies its own installation, compatibility, policy, credential and commissioning checks. A self-entered score, successful simulation or exported ZIP grants none of those gates.

Previously imported certified packages can be re-exported only through the verified retained-package path when eligible. Editing the draft does not preserve certification for the changed revision.

◇

Reference

Which controls work in standalone Studio?

Test runs a no-write draft simulation. Certify directs you to connect, save and send the draft to Executor; it does not issue certification. Agent updates opens the connected Executor, where Import agent accepts a reviewed signed replacement package from the same trusted developer. Automatic capability refresh is unavailable: edit the draft, then Check and Test it. Delete local draft removes only the selected saved draft after confirmation and rejects stale revisions; its saved version history and installed Executor agents are retained.

Runtime replay, learning, evaluations and commissioning belong to Executor. A saved draft or successful simulation does not make an installed agent ready for production.

A trusted package with valid independent Fabric Intelligence certification and satisfied dependencies can become ready immediately for manual governed runs, without a second commissioning step. Automatic routing and production-effect authority remain disabled. Other valid imports stay disabled/decommissioned until their admission requirements are met. Unknown, invalid or revoked signatures are quarantined.