Deploying Architecture Studio on Eve — Docs

Architecture Studio started as a Claude plugin system for architects and interior designers. It packages architecture-specific agents, skills, rules, and hooks for site research, zoning, workplace programming, specifications, sustainability, materials research, presentations, and project memory.

eve gives that same body of work a deployable agent harness.

Use this guide when you want Architecture Studio to run as a durable web agent instead of only as a local Claude Desktop / Claude Code plugin. The goal is not to copy the plugin marketplace one-to-one. The goal is to lift the useful parts of Architecture Studio into an eve app: a root studio agent, specialist subagents, reusable skills, controlled tools, route auth, sandbox policy, and a deployable runtime.

What you are deploying

An eve deployment of Architecture Studio should have six layers:

Root studio agent: receives the request, asks clarifying questions, routes work, and preserves review expectations.
Specialist subagents: site planner, NYC zoning expert, workplace strategist, product and materials researcher, FF&E designer, sustainability specialist, and brand manager.
Skills: focused procedures for tasks like product research, project dossier updates, zoning analysis, EPD parsing, CSI spec writing, and slide generation.
Tools and connections: typed integrations for files, APIs, material libraries, project stores, search, and any firm systems.
Memory: project dossiers, decision records, and product/material memory through Norma.
Review and auth: route protection, human approvals, disclaimers, source expectations, and bounded sandbox access.

The existing Architecture Studio plugin install guide is still the right starting point for Claude Desktop and Claude Code. See Installing Architecture Studio for that path. This page covers the eve deployment path.

Prerequisites

You need:

Node.js and a package manager such as npm, pnpm, or yarn.
The eve CLI installed or available through your package scripts.
A Vercel account if you want the easiest hosted deployment path.
A model routing plan: Vercel AI Gateway, AI_GATEWAY_API_KEY, or direct provider credentials such as ANTHROPIC_API_KEY or OPENAI_API_KEY.
A route-auth policy for production access.
A local copy of Architecture Studio:

git clone https://github.com/AlpacaLabsLLC/skills-for-architects.git

Create the eve app

Start with a fresh eve app:

eve init architecture-studio-eve
cd architecture-studio-eve

eve discovers an agent from the filesystem under agent/. The recommended shape is:

architecture-studio-eve/
├── package.json
├── agent/
│   ├── agent.ts
│   ├── instructions.md
│   ├── channels/
│   ├── skills/
│   ├── tools/
│   ├── sandbox/
│   └── subagents/
└── evals/

Identity comes from paths. A file at agent/skills/project-dossier.md becomes the project-dossier skill. A subagent at agent/subagents/site-planner/agent.ts becomes the site-planner subagent.

Configure the root agent

Create or update agent/agent.ts:

import { defineAgent } from "eve";

export default defineAgent({
  model: "anthropic/claude-opus-4.8",
  reasoning: "high",
});

String model IDs route through Vercel AI Gateway. On Vercel, gateway models can authenticate through project OIDC after the project is linked. Outside Vercel, set AI_GATEWAY_API_KEY.

If you want to call a provider directly, install the provider package and pass the provider model object:

npm install @ai-sdk/anthropic

import { anthropic } from "@ai-sdk/anthropic";
import { defineAgent } from "eve";

export default defineAgent({
  model: anthropic("claude-opus-4-8"),
  reasoning: "high",
});

With this shape, set ANTHROPIC_API_KEY in the deployment environment.

Write the root instructions

Create agent/instructions.md as the studio router. Keep it firm-specific enough to be useful and bounded enough to review.

# Architecture Studio

You are Architecture Studio, an agent harness for architecture and interior design workflows.

Route work to specialist subagents when the task has a clear domain. Use skills for focused procedures. Preserve sources, assumptions, review states, and professional responsibility.

You can support:

- site research and project due diligence
- NYC zoning and property analysis
- workplace programming and occupancy planning
- specifications and CSI outline writing
- sustainability and EPD review
- product, material, and FF&E research
- project dossiers and decision records
- presentation support

Never represent draft AI output as professional approval. For regulatory, code, specification, sustainability, or procurement output, include source references and identify what requires architect review.

This root prompt should link the eve deployment to the same operating philosophy used by Architecture Studio: agents are useful when they are narrow, sourced, and reviewable.

Add Architecture Studio skills

Architecture Studio skills live in the GitHub repo under skills/*. In eve, skills belong under agent/skills/.

For a first deployment, do not migrate every skill. Start with the workflows that benefit most from a durable web agent:

project-dossier
decision
product-research
product-data-cleanup
master-schedule
spec-writer
environmental-analysis
zoning-analysis-nyc
workplace-programmer
slide-deck-generator

Copy or adapt each skill into agent/skills/. Keep file names stable and action-oriented. For example:

agent/skills/
├── project-dossier.md
├── decision.md
├── product-research.md
├── product-data-cleanup.md
├── master-schedule.md
├── spec-writer.md
├── environmental-analysis.md
├── zoning-analysis-nyc.md
├── workplace-programmer.md
└── slide-deck-generator.md

Skills should stay procedural. Put domain judgment in instructions, but put API calls, file access, and state changes into tools.

Add specialist subagents

Subagents let the root studio agent delegate to bounded specialists. Each local subagent lives under agent/subagents/<id>/ and needs its own agent.ts. The description is important because the parent uses it to decide when to delegate.

Example:

agent/subagents/product-and-materials-researcher/
├── agent.ts
├── instructions.md
└── skills/

import { defineAgent } from "eve";

export default defineAgent({
  model: "anthropic/claude-opus-4.8",
  description:
    "Researches products, materials, FF&E options, product data cleanup, substitutions, and material library updates for architecture and interiors projects.",
});

Start with these Architecture Studio subagents:

Subagent	Use it for
`site-planner`	Site context, mobility, demographics, environmental analysis, and neighborhood research.
`nyc-zoning-expert`	NYC due diligence, zoning checks, property data, and buildable envelope analysis.
`workplace-strategist`	Workplace programming, headcount planning, room schedules, and occupancy planning.
`product-and-materials-researcher`	Product search, product facts, material alternatives, and library updates.
`ffe-designer`	FF&E schedules, room packages, schedule cleanup, and SIF/CSV workflows.
`sustainability-specialist`	EPDs, GWP comparison, LEED-relevant product research, and specification thresholds.
`brand-manager`	Slide decks, visual QA, color palettes, and presentation formatting.

Keep subagents narrow. A useful Architecture Studio deployment is a system of specialists, not one generic assistant with every instruction loaded at once.

Add tools and connections

Use eve tools for actions that should be typed, audited, or constrained:

read and write project dossier files
create decision records
search a product library
call Norma APIs or MCP tools
fetch approved public data sources
normalize product rows
create or update schedules
generate files into a sandbox workspace

Tool files live under agent/tools/. Their names come from the path, so agent/tools/search_norma.ts becomes the search_norma tool.

Reserve tools for actions. Keep skills as instructions for how to perform a workflow.

Connect Norma as material memory

Norma should be treated as the product and material memory layer for an Architecture Studio deployment.

A product research agent can search the open web, but firm value comes from knowing what the studio has already selected, rejected, substituted, quoted, or approved. Norma gives those facts a durable place to live.

In an eve app, connect Norma through tools or connections that support:

product search against firm-owned records
product data cleanup and normalization
project-to-product references
approved substitutions
source URLs and manufacturer facts
private notes such as vendor responsiveness or client feedback

Then make the material agents use Norma before treating public web search as the only source of truth.

Configure route auth

Do not ship a production browser-facing agent with placeholder auth.

eve protects session routes at the channel layer. Create or update agent/channels/eve.ts:

import { eveChannel } from "eve/channels/eve";
import { localDev, vercelOidc } from "eve/channels/auth";

export default eveChannel({
  auth: [vercelOidc(), localDev()],
});

This is a reasonable Vercel-to-Vercel starting point. For a firm deployment, you will usually replace or extend it with your app session, SSO, JWT/OIDC, or another verifier. Put your real authenticator before broad fallbacks.

Production browser traffic fails closed unless an authenticator accepts it. GET /eve/v1/health remains public for health checks.

Configure the sandbox

eve runs tool work in a sandbox. On Vercel, the default backend uses Vercel Sandbox. Outside Vercel, the default backend selects a local backend in availability order.

Add an explicit sandbox only when you need seeded workspace files, bootstrap behavior, or a pinned backend:

agent/sandbox/
├── sandbox.ts
└── workspace/

For Architecture Studio, seed only reusable templates and examples. Do not seed client confidential project files into the app repository. Project-specific data should come from authenticated storage, uploaded files, or a firm-controlled project memory layer.

Run locally

Inspect discovery first:

eve info

Then run the local agent:

eve dev

Before deploying, build:

eve build

Useful eve artifacts are written under .eve/, including discovery diagnostics and the compiled manifest. If a skill, tool, or subagent is not available, eve info is usually faster than debugging through a chat session.

Deploy on Vercel

Link the project:

eve link

Set the required environment variables in Vercel:

model credentials or AI Gateway access
route-auth secrets
Norma credentials or API endpoints, if used
any external service credentials used by tools

Deploy:

eve deploy

You can also deploy with Vercel directly:

vercel deploy

During a hosted Vercel build, eve build writes Vercel Build Output under .vercel/output. Vercel Workflow handles durable runs, and the default sandbox backend uses Vercel Sandbox.

Verify production

Check health:

curl https://<your-app>/eve/v1/health

Create a session:

curl -X POST https://<your-app>/eve/v1/session \
  -H "content-type: application/json" \
  -d '{"message":"Create a project dossier outline for a small workplace renovation."}'

Then connect the eve dev UI to the deployed app:

eve dev https://<your-app>

Use a simple prompt first. Confirm the root agent can answer. Then test one subagent route, one skill, one tool, and one workflow that needs human review.

Deployment checklist

eve info discovers the root agent, skills, tools, and subagents.
eve build succeeds.
The route-auth policy is real and not placeholder-only.
Model credentials are configured in the deployment environment.
Sandbox behavior matches the host environment.
Project memory does not depend on files committed to source.
Product and material workflows check Norma where available.
Regulatory, code, specification, sustainability, and procurement outputs include review language and sources.
Production health and session routes respond.