# Creating Artifacts Source: https://docs.architect.new/build/artifacts Generate documents, presentations, and reports alongside your app — right inside Build Mode. ## What Are Artifacts? While building your app, you can ask Architect to create standalone documents as **artifacts** — files that appear in the **Artifacts tab** in the right panel, where you can view, download, or share them. Artifacts are generated in the same conversation as your app, so Architect already has full context of what you're building. You don't need to copy anything out or switch tools. Artifacts tab in Architect Build Mode showing a Feature Spec PDF ## What You Can Create Ask Architect to generate any document that relates to your app or idea: * **Feature spec documents** — a structured breakdown of what the app does, who it's for, the agent architecture, and key screens. Useful for sharing with stakeholders or investors. * **Presentations** — a slide deck or HTML presentation covering the app's use case, value proposition, and how it works. * **Research documents** — background research, competitive analysis, or market context relevant to the problem your app solves. * **Word / HTML documents** — any freeform document you need: onboarding guides, SOPs, product briefs, or anything else. Artifact document open in the Architect right panel ## How to Create an Artifact Just ask in the build chat. For example: > *"Can you create a feature spec PDF for the app we just built?"* > *"Build me a presentation about this app's use case."* > *"Write a research doc on the market this app targets."* Architect generates the document and places it in the **Artifacts tab** (next to Plan, Agents, App, and Database). Click to open it in the panel, or hit **Download** to save it locally. You can create artifacts at any point — while the app is being built, or after it's complete. # How to Build an App Source: https://docs.architect.new/build/build-guide Building an app with Architect is designed to be as intuitive as describing your idea to a product manager. Whether you want a quick prototype or a carefully crafted enterprise solution, Architect adapts to your workflow through two distinct modes. ## Get Inspired & Personalize **Best for:** Users who know they want to automate work but aren't sure exactly what to build first. When you first enter Architect, you aren't just greeted by a blank prompt. You meet your AI Consultant. Before you write a single line of text, Architect helps you identify the highest-value opportunities for automation in your specific role. The Architect home page showing the prompt input and mode selector ### How it works: * **Tell us about your role:** Input your job title (e.g., "Sales & Marketing"). * **Identify Bottlenecks:** Tell Architect what takes up the most time in your week (e.g., "Lead Outreach" or "Scheduling"). * **List your Stack:** Mention the tools you already use (e.g., Apollo, Linear, Google Calendar). **The Result:** Architect immediately generates Tailored App Ideas on the right-hand panel. These aren't generic suggestions; they are specific agentic use cases mapped to your pains, complete with estimated time savings (e.g., "Lead Nurturing Agent - Save 15 hrs/week"). You can choose one of these pre-validated ideas to start building immediately, or use them as inspiration for your own custom prompt. The AI Consultant's Recommended Agents with capability lists and weekly time-savings estimates ## Prompting Guidelines The quality of your app depends on the quality of your initial prompt. Since Architect uses "vibe-coding," you don't need to speak technical jargon, but you do need to be clear about intent. ### Effective Prompting Checklist: * **The "Who":** Who is this app for? *(e.g., "A dashboard for HR managers," "A study aid for medical students")* * **The "What":** What is the core problem? *(e.g., "They spend too much time manually screening resumes")* * **The "Vibe":** How should it feel? *(e.g., "Professional and data-dense," "Playful and gamified," "Minimalist and text-heavy")* * **Success Criteria:** What does a "done" task look like? *(e.g., "The user should get a summarized PDF report at the end")* You don't need to list every single feature. Focus on the **User Journey**. "Make an app with a text box and a button that calls an API." "Build a travel planner where a user enters their dates and interests, and the app generates a day-by-day itinerary including flight options and hotel recommendations." ## The Build Process Architect acts as your **Lead Product Manager**. It analyzes your prompt and generates a detailed Product Requirements Document (PRD). **What happens here?** * Architect outlines the User Journey. * It identifies which AI Agents are needed (e.g., a "Researcher Agent" and a "Writer Agent"). * It defines the App UX and wireframe structure. **What to validate:** * **Agent Roles:** Are the agents correctly identified? Does the "Researcher" have access to the web? * **Flow:** Does the step-by-step user journey make sense? * **Missing Features:** Did it forget that you need a "Save to PDF" button? If something looks wrong, chat with Architect to refine the plan before clicking "Push to Agents." The Plan phase view showing the generated PRD with Approve and Chat/Edit options Once the plan is locked, Architect enters the engineering phase. It constructs the backend orchestration, initializing the agents, assigning them tools, and linking knowledge bases. **Key Components:** * **Agents:** The distinct AI personas performing tasks. * **Knowledge Base (KB):** This comes into picture if your agents need to know specific proprietary info (e.g., your company's HR policy PDF). Architect will flag if a KB is needed. * **Tools:** This is where capabilities are added. If an agent needs to send an email, search the web, or query a database, a "Tool" is attached to that agent. **🔧 Refining in Lyzr Studio** Sometimes you need to go under the hood. You can click to edit any agent, which will take you to [Lyzr Studio ↗](https://studio.lyzr.ai/). * **Edit Instructions:** Fine-tune the system prompt for specific agents. * **Test Independently:** Run test queries on just one agent to ensure it behaves correctly before the full app is built. The Agents phase showing the network of agents and Edit in Studio button In the final phase, Architect builds the UX layer. It takes the structured outputs from your agents and wraps them in a polished user interface. **What happens here?** * Generation of the frontend code (React/Next.js). * Wiring of UI components to Agent outputs. The App phase showing the generated code preview and chat interface ## Refining Your App Building the app is just the beginning. At any phase, or even after the app is deployed, you can continue to chat with Architect. **Example refinements:** * "The Researcher Agent is too verbose. Make it more concise." * "Change the UI theme to dark mode." * "Add a new feature: allow users to email the results." Architect will iterate on the existing codebase and agent configuration to implement your feedback instantly. ## Deploying Your App Once you are satisfied with the preview, you need to publish it to the world. * **Action:** Click the Deploy button on the top right corner. * **Outcome:** Architect will push your application to a live production environment. * **Share:** You will receive a unique, public URL (e.g., travel-planner.architect.new). You can share this link immediately with users or colleagues. The deployment success dialog showing the live URL and options to copy or open the app # Bring Your Own Design System Source: https://docs.architect.new/build/custom-theme Turn your own design guidelines into a reusable theme — import them from Figma, a PDF, a GitHub repo, or a zip, add design instructions and brand assets, and Architect applies that look to every app you build. Architect ships with 45+ ready-made themes, but you don't have to settle for a preset. With **custom themes** you can bring your own design system — import your brand's guidelines, layer on your own instructions and assets (like your company logo), and Architect will apply that exact look and feel consistently to every app you build with it. You can import your design guidelines in whatever form you already have them: a Figma file, a design-guidelines PDF, a GitHub repo, a zip of your codebase, or raw CSS. ## Set Up Your Theme From the homepage prompt box, click the **+** menu and choose **Select theme**. The + menu in the prompt box with the 'Select theme' option highlighted This opens the **Theme Manager**, where you can browse the built-in presets or click **Create theme** to build your own. Choosing **Create theme** gives you several ways to import your design guidelines (see [Ways to Import](#ways-to-import) below) — pick whichever matches what you already have. The Theme Manager showing the Create theme options: paste globals.css, generate from a design doc, upload a zip, import from GitHub, and import from Figma Architect turns your import into a theme and opens the **design system editor**. Here you can give it a **name** and description, fine-tune the generated **globals.css**, add **instructions** for how the design system should be used, and attach **assets** such as your company logo. A **live preview** (Components, Text, Palette) shows exactly how the theme will look before you apply it. When it's valid, click **Save changes**. The Edit design system editor with the globals.css code, live preview, and tabs for Instructions and Assets ## Ways to Import Pick the source that matches what you already have — Architect handles the rest. Paste a Figma file link and Architect extracts its colors and typography into a theme. *(Beta — restricted access.)* Upload a PDF, Word doc, or text file of your brand or design guidelines, and Architect derives the theme from it. Connect a repository and pick a branch — Architect reads the code directly and builds a matching theme. Drop in a zip of your codebase and Architect browses the code to write a theme that matches it. Already have a Tailwind / shadcn `globals.css`? Paste it in and edit it directly, with a live preview as you go. ## Fine-Tune Your Theme Once imported, the design system editor lets you shape every part of the theme: Edit the underlying CSS variables — colors, fonts, radii, and more. Architect validates it as a proper shadcn `globals.css`. Add notes and rules about how your design system should be applied, so Architect honors your conventions while building. Upload brand assets — like your company logo — for Architect to use across the apps it generates. Preview the theme on real components, text, and the full color palette before applying it to any build. Once saved, your custom theme lives in the **Theme Manager** alongside the presets. Select it before you build (the same **+ → Select theme** menu) and Architect applies it to the generated app — giving every project you build a consistent, on-brand design. # Database & Authentication Source: https://docs.architect.new/build/database-auth Architect doesn't just build UI screens. It automatically provisions a fully managed backend, complete with a NoSQL database and secure authentication flows. ## Fully Managed Backend One of the most challenging parts of traditional software development is setting up the backend infrastructure. Architect eliminates this entirely. When you prompt an application that requires saving data, managing users, or storing history, Architect automatically spins up a robust backend for you. The Database tab showing collections and documents for a generated app ### The Database Tab Inside the Architect builder, you have direct access to the **Database** tab. This acts as your visual data explorer. * **Auto-Generated Collections:** Architect anticipates your data needs based on your prompt. If you build a chat app, it automatically creates collections like `_users`, `characters`, `conversations`, `messages`, and `preferences`. * **Live Data Viewer:** You can click into any collection to see the live documents (rows) currently stored in your app's database. * **Schema Management:** You can view how your data is structured, including timestamps, unique IDs, and relationship mapping. ## Secure Authentication If your application requires user accounts (e.g., a SaaS tool or a private internal dashboard), Architect handles the entire authentication flow out of the box. ### What Architect builds for you: * **Sign In / Sign Up UI:** Clean, modern authentication screens that match your app's chosen aesthetic theme. * **Secure Storage:** User credentials (like passwords) are automatically securely hashed (e.g., using bcrypt) before being stored in the `_users` collection. * **Session Management:** The generated application code handles login states, token management, and protecting private routes from unauthorized access automatically. # Deployment & Publishing Source: https://docs.architect.new/build/deployment Take your app from a development sandbox to a live, production-ready public URL that you can share with the world. ## Making Your App Live Once you have validated your application in the 'Live App' preview and are satisfied with the UI and agent performance, it is time to deploy. Architect handles the hosting and server management automatically. Click the **Deploy** button in the top right corner of the builder to open the deployment configuration. The Deploy Your App modal with Custom Domain, Analytics, and Publish to Marketplace options ## Deployment Configuration Before pushing your app live, you can configure how it behaves and how it is discovered. ### 1. Custom Domains By default, Architect provides a fast, secure sub-domain for your application. However, if you are building a customer-facing SaaS or a branded internal tool, you can connect your own custom domain (e.g., `tools.yourcompany.com`) directly through this menu. ### 2. Analytics Tracking Enable built-in analytics to track your application's usage and performance. This allows you to monitor how many users are interacting with your app and how often your AI agents are being triggered. ### 3. Publish to Marketplace If you have built something incredible and want to share it with the community, toggle on **"Publish to Marketplace"**. This will list your app in the [Marketplace](/introduction/platform/agentlets) directory. To publish, you will need to provide: * **Category:** Select the primary industry or function (e.g., 'Productivity', 'Finance', 'Marketing'). * **Description:** A detailed explanation of what your agent does and how users can benefit from it. * **Short Description:** A brief, 160-character summary that appears on your app's card in the marketplace grid. * **Tags:** Add up to 8 keywords (e.g., `SEO`, `Lead-Gen`, `Dashboard`) to make your app highly searchable. # Environment Variables Source: https://docs.architect.new/build/environment-variables Bring your own API keys and secrets into any Architect-built app. ## What Are Environment Variables? Every app Architect builds runs in a sandboxed environment. If your app needs to connect to an external service — a third-party API, a custom database, a payment provider — you can add your own secrets and config values as **environment variables**. These are injected into your app's sandbox and available via `process.env` in the app code. Environment Variables option in the Architect app menu Open the **⋮ menu** in the top-right corner of your app and select **Environment variables** to open the panel. Environment variables panel showing name and value fields with encrypted storage notice Add a **Name** (e.g. `STRIPE_SECRET_KEY`) and its **Value**, then hit **Add**. Values are encrypted at rest. The AI builder running in your app's sandbox can read them to wire them into your code automatically. ## Some Cases Where This Comes in Handy **Bring your own API key.** If you want to use a specific provider — OpenAI, ElevenLabs for voice, SendGrid for email — add your API key here instead of relying on shared system keys. Your key, your quota, your billing. **Voice & transcription.** If you want to add voice input or audio transcription to your app using OpenAI Whisper, add your `OPENAI_API_KEY` here and ask Architect to wire it up. **Connect an external database.** If you have your own Postgres, Supabase, or any other database you want the app to read from or write to, add the connection string here (e.g. `DATABASE_URL`) and ask Architect to integrate it. **Third-party integrations.** Any external service your app talks to — a CRM, a data provider, a custom internal API — can be connected this way. Add the key, then prompt Architect to use it. After adding or updating environment variables, ask Architect to pick them up — for example: *"I've added an `OPENAI_API_KEY` — can you wire up voice transcription using Whisper?"* # GitAgent (Beta) Source: https://docs.architect.new/build/git-agents Build your app's agent as a git-native agent — identity, rules, skills, and memory live as plain files in a GitHub repo you own. GitAgent in Architect is an early **beta** feature. You can create one today and it works end to end, but it does not yet change how your app's interface looks or behaves — for now, there's no difference in the final app UI. If you're unsure, keep the default Lyzr agents. ## What is GitAgent? When Architect builds a normal app, the AI agents that power it are **hosted Lyzr agents** — they live inside Lyzr Studio and you configure them there. **GitAgent** takes a different approach: **your agent lives inside a git repository.** Its identity, rules, skills, tools, and memory are all version-controlled files. This is the *"agents as repos"* idea — instead of your agent's configuration being locked inside a platform, it's plain, readable code you own and control. GitAgent is built on **GitAgentProtocol (GAP)** — an open standard for git-native AI agents, maintained by Lyzr Research Labs. GitAgent is its own open project with a full harness, SDK, and CLI. Explore it at **[gitagent.sh](https://www.gitagent.sh/)**. **Why git-native?** * **Audit trail** — `git log` your agent's memory and track every change to how it behaves. * **Version control** — fork an agent, branch a personality, roll back to a previous version. * **No vendor lock-in** — the agent is portable files (Markdown + YAML), not rows in someone's database. * **Reviewable** — your agent's behavior is code you (and your team) can read and review like any repo. ## The agent repo structure When Architect creates a GitAgent, it generates a repository with a standard file layout. Each file defines one part of how the agent thinks: | File / folder | What it defines | | ------------- | ----------------------------------------------------------------------------- | | `SOUL.md` | The agent's **identity & personality** — who it is, its voice and character | | `RULES.md` | **Hard constraints** — the "must always" and "must never" rules it follows | | `DUTIES.md` | **Responsibilities** — the core tasks and duties the agent is responsible for | | `agent.yaml` | The **manifest** — model selection, runtime settings, and configuration | | `skills/` | **Composable skill modules** — specific capabilities the agent can invoke | | `memory/` | **Git-committed memory** — what the agent remembers, with full history | | `knowledge/` | **Knowledge files** — reference material the agent draws on | Because it's all just files in a repo, you can read, edit, version, and share your agent exactly like any other codebase. ## Lyzr Agent vs GitAgent The two agent types are configured in completely different places. Here's the difference: | | **Lyzr Agent (default)** | **GitAgent (beta)** | | ----------------------------------- | ----------------------------- | ----------------------------------------------------------- | | **Where it lives** | Inside **Lyzr Studio** | Inside a **GitHub repo** you own | | **How you configure it** | Open the agent in Lyzr Studio | Edit plain files in the repo | | **Role, goal, instructions, model** | Set in Lyzr Studio | Defined in `SOUL.md`, `RULES.md`, `DUTIES.md`, `agent.yaml` | | **Tools** | Attach a tool in Lyzr Studio | Defined as files in the repo | | **Knowledge base** | Attach a KB in Lyzr Studio | Files in `knowledge/` | | **Memory** | Managed by the platform | Version-controlled in `memory/` | | **Versioning / audit** | Platform-managed | Full git history — fork, branch, diff, revert | In short: a **Lyzr agent** is controlled entirely from **Lyzr Studio**, while a **GitAgent** is controlled entirely by the **files in its GitHub repo**. ## How to create a GitAgent in Architect While planning a new app, Architect asks — as the last, optional question — whether you want to build with GitAgent. Select **"Build this using GitAgent (beta feature)"** instead of the default Lyzr agents, then continue building. The optional GitAgent question in Architect's planning flow, with 'Build this using GitAgent' selected ## Viewing your GitAgent's details Once your app is built, open the **Agents** tab and click your git-native agent to see its full definition — its **Soul** (identity & personality), **Rules** (hard constraints), and **Duties** (responsibilities) — read straight from the repo. Use **View repository on GitHub** to jump to the source. A GitAgent's detail panel in Architect showing its Soul, Rules, and Duties, with a View repository on GitHub button ## Your GitAgent's GitHub repo If your GitHub is connected, Architect creates and pushes the agent's repository to your account. You'll see the full file structure — `SOUL.md`, `RULES.md`, `DUTIES.md`, `agent.yaml`, and the `skills/`, `memory/`, and `knowledge/` folders — and every change Architect makes is committed there. A GitAgent repository on GitHub created by Architect, showing SOUL.md, RULES.md, DUTIES.md, agent.yaml, and the skills, memory, and knowledge folders ## Who is it for? Consider building with GitAgent if you: * Want to **own and inspect** exactly how your agent thinks, as files you control * Want to **version, fork, branch, or roll back** your agent like a normal codebase * Care about an **audit trail** and reviewable agent behavior * Are comfortable being an **early beta user** while the experience is still growing If you just want a working app as fast as possible, the **default Lyzr agents** are the right choice — you can always try GitAgent later. ## What's next — our vision for GitAgent Today, Architect can create a full GitAgent with all of GitAgent's capabilities — identity, rules, duties, skills, memory, and knowledge, all versioned in your own repo. Our ultimate aim is to give every GitAgent its own **agent workbench UI** — a dedicated, purpose-built interface for your git-native agent instead of just powering a standard app behind the scenes. Think of a full agentic workspace built around the agent: a place to talk to it, watch what it's doing in real time, review and refine its files (soul, rules, skills, memory), and drive its skills and workflows directly. That agent-workbench experience is what we're ultimately building toward with GitAgent. # Connecting Your GitHub Source: https://docs.architect.new/build/github-connect Push your Architect-generated app straight to your own GitHub repository and keep it in sync as you iterate. ## Why Connect GitHub? Architect isn't a walled garden. If you connect your GitHub account, the full source code of any app you build can be pushed into a repository you own — so you can clone it, run it locally, collaborate with your team, or deploy it wherever you want. ## How to Connect Inside any app you've built, click the **GitHub icon in the top-right corner** of the app view, then authenticate with your GitHub account. GitHub icon in the top-right corner of the Architect app view After signing in, GitHub will ask you to **authorize Lyzr Architect** to access your account. Approve the request to grant Architect permission to create and push to repositories on your behalf. GitHub authorization screen granting Lyzr Architect access Once authorized, Architect creates a repository for your app and pushes the initial codebase to your account. ## Automatic Commits on Every Change After GitHub is connected, you don't need to manually sync anything. Every change you make in Architect — whether it's refining an agent, tweaking the UI, or updating a prompt — is automatically pushed to your repository as a new commit. This means your GitHub repo always mirrors the latest state of your app in Architect, giving you a full version history out of the box. ## Pull, Push & Branch Switching Once your app is connected to GitHub, you get manual **Pull** and **Push** controls alongside the auto-commit flow — so you can explicitly sync code in either direction whenever you need to. Pull, Push and branch switcher controls in the Architect GitHub panel **Switching branches.** Architect supports working across multiple branches of the same repository. To switch to a different branch: 1. Create the branch locally in your repo and push it to GitHub. 2. Open the GitHub panel in Architect and select the branch from the branch switcher. 3. Architect pulls the latest code from that branch into the sandbox and continues building from there. This means you can maintain separate branches for different features or experiments, switch between them in Architect, and keep each one in sync independently — just make sure the branch exists on GitHub before switching. # Plan Mode Source: https://docs.architect.new/build/plan-mode While iterating on an app, flip the Plan toggle to think a change through with Architect before building it — then switch back to Build to ship it. Once your app is built, you don't have to commit to a change the moment it crosses your mind. The chat box has a **Plan** toggle. Flip it on and Architect switches from *doing* to *thinking* — it plans the change, proposes ideas and an approach, and breaks the work down, all **without touching your code**. Flip it off and you're back in **Build** mode, where Architect implements. Because both modes share the same chat, you can move fluidly between them — plan an idea, build it, plan the next one — toggling as you go without ever losing context. **Plan Mode vs. Planning & Brainstorming.** Plan Mode is for iterating on an app that **already exists**. To plan and brainstorm *before* your first build, see [Planning & Brainstorming](/build/planning-brainstorming). ## How to Use Plan Mode In any app's build chat, find the **Plan** switch at the bottom-left of the message box and turn it on. Your next message will be sent in planning mode instead of build mode. The Plan toggle at the bottom-left of the chat, with Architect returning a 'Planning'-tagged response of feature ideas Describe what you're considering — *"what other features can I introduce in my app?"*, *"how would we add authentication?"*, or *"plan a redesign of the dashboard."* Architect replies with a **Planning**-tagged answer: feature ideas, scope, trade-offs, and a suggested approach — laid out clearly so you can think it through. Nothing is built yet, so you're free to explore options and refine the idea with follow-up messages. Happy with the plan? Toggle **Plan** back off to return to **Build** mode, then ask Architect to go ahead. The plan you just shaped becomes the blueprint for the change, so the build is faster and lands closer to what you intended. ## When to Use Plan Mode Before a large or risky edit, map out exactly what needs to happen so the build doesn't go sideways. Not sure what to add next? Ask Architect for ideas that fit your app — and pick the ones worth building. Weigh different ways to solve a problem and agree on the direction before any code changes. Lock in the plan first so you don't spend a build cycle on a change that wasn't quite right. Plan and Build mode share one continuous conversation. Plan an idea, build it, then plan the next — just flip the toggle whenever you want Architect to think before it acts. # Planning & Brainstorming Source: https://docs.architect.new/build/planning-brainstorming Before Architect builds anything, plan and brainstorm your idea with it — refine the requirements, preview how the app will look, and generate reusable artifacts that get handed straight to the build. The moment you submit your first prompt, Architect doesn't jump straight into code. It drops you into **Planning mode** — a dedicated space to think your idea through, pin down the details, and *see* what you're about to build before a single line is written. Here you can brainstorm freely, answer a few guided questions, preview the app's design, and produce supporting artifacts — a plan/PRD, a workflow diagram, skill files, even a PDF or slide deck — that are passed to the build so your app starts with real context instead of a blank slate. Planning mode opens **automatically** as soon as you enter a prompt on the homepage. In a hurry? You can skip ahead to the build at any time with **Start Building**. ## How Planning Mode Works Describe what you want to build in plain language from the homepage — for example, *"Build a marketing team of agents that can write blog posts, create social media content, perform SEO analysis, and generate graphics for my brand."* No structure or technical detail required. The Architect homepage with a use-case prompt typed into the input box Architect opens Planning mode and asks a few focused questions to understand your use case — which content types matter most, how hands-on you want to be, whether you need to save data across sessions, and more. Pick from the suggested options or just type your own thoughts to brainstorm back and forth. Every answer sharpens the plan, so the result is shaped around *your* actual workflow rather than a generic template. Planning mode asking guided, multiple-choice questions to scope the use case From the conversation, Architect drafts a complete **plan / PRD** in the right panel — an overview, user stories, the **agent architecture** (which agents are needed and how they're orchestrated), detected data sources, and a full agent table listing each agent's model, tools, and role. Want to change something? Just keep chatting — the plan updates live as you refine it. The generated Plan/PRD showing overview, user stories, and agent architecture Alongside the plan, Architect generates an **App Mockup** — a high-fidelity preview of how your finished app's UI will actually look — so you can brainstorm and iterate on the design *before* it's built. It also produces a **workflow diagram** of the agent flow and any **skill files** for specific tasks. Each artifact opens in its own tab. Recommended follow-ups (for example, *"design the Blog Studio editor"* or *"author a skill for the Social Repurposer"*) appear as one-click suggestions so you can keep expanding the plan. The App Mockup preview alongside the plan, workflow diagram, and skill file tabs When the plan is marked **Plan Ready**, click **Start Building**. Everything you created in Planning mode — the PRD, the app mockup, the workflow diagram, and the skill files — is handed to the build, so Architect starts with a clear blueprint of exactly what you want. Need to keep refining? Use **Back to Plan Mode** anytime. ## What You Can Generate Planning mode is more than a chat — it's where you produce the building blocks your app is made from. Each of these is passed to the build automatically. A high-fidelity design preview of your final app's UI. Brainstorm and iterate on the look and feel before any code is written. A structured product requirements doc: overview, user stories, agent architecture, detected data sources, and the full agent table. A visual map of how your agents connect, trigger one another, and hand off work. Reusable instruction files for a specific task — like long-form blog writing or SEO keyword research — that your agents use once the app is built. Export a polished document or slide deck for your use case — handy for sharing the concept or getting stakeholder buy-in. Scaffold the supporting files your app will need so the build has somewhere to start. Every artifact you generate in Planning mode is carried into the build. The more you plan and brainstorm here, the more context Architect has — and the closer the very first build lands to what you actually want. # Prompt Library Source: https://docs.architect.new/build/prompt-library A curated collection of high-performance prompts, ready to use as-is or as a starting point for your own builds. ## What is the Prompt Library? The **Prompt Library** is a handpicked collection of production-grade prompts — organized by role, industry, and task — that consistently produce high-quality agentic apps in Architect. Each entry is a fully specified blueprint: the user journey, the agents involved, and the expected output are all pre-engineered for you. Use it when you want to: * **Skip the blank-page problem** — grab a prompt that's close to your goal and tweak from there. * **Explore what Architect can do** — browse categories to discover automation ideas you hadn't considered. ## How to Access the Prompt Library The Prompt Library lives in the **left sidebar** of the Architect homepage. Click **Prompt Library** to open the full collection. Prompt Library in the Architect homepage left sidebar Once you open the library, you'll see prompts grouped by function — Sales & Marketing, Operations, Product & Engineering, HR, Finance, and more. Click any prompt to instantly load it into the prompt bar, ready to build. Prompt Library inside Architect showing categorized prompt blueprints Every prompt in the library is editable. Load it, adjust the specifics to match your context (industry, tools, success criteria), and hit send — Architect will build from your customized version. # Sharing an App Source: https://docs.architect.new/build/share-app Invite teammates to collaborate on any Architect app you've built — they get full access to work on it alongside you. ## Why Share an App? Architect apps aren't solo projects. Once you've built an app, you can share it with anyone on your team so they can open it, iterate on it, and build on top of it — just like you. ## Step 1: Open "My Projects" From the homepage sidebar, click **My Projects**. This view lists every app you've built. My Projects tab in the Architect homepage sidebar ## Step 2: Click the Share Icon Each app card has a **share icon** next to the Open button. Click it on the app you want to share. Share icon on an app card inside My Projects ## Step 3: Enter the Collaborator's Email A share dialog opens. Enter the email address of the person you want to share the app with, then click **Share**. You can invite multiple people to the same app, and everyone you add will appear under **People with access**. Share dialog prompting for a collaborator's email address ## Step 4: Collaborators See It in "Shared Projects" Anyone you've shared an app with can find it by clicking **Shared Projects** in their own homepage sidebar. From there, they can open the app and work on it just like the original creator. Shared Projects tab in the homepage sidebar Every person with access works on the **same app** — there's no fork or copy. Changes anyone makes are reflected for everyone collaborating. # Release Notes Source: https://docs.architect.new/changelog/overview New features, improvements, and fixes shipped in Lyzr Architect. Track everything new in Lyzr Architect — new features, improvements, and fixes, released every week. | Version | Date | Highlights | | --------------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | | [v2.2.0](/changelog/v2-2-0) | August 7, 2026 | Testing agent (auto-test & self-fix), deploy without GitHub, import a GitHub repo, rename deployed URL, per-agent credit breakdown, more reliable previews | | [v2.1.0](/changelog/v2-1-0) | July 27, 2026 | GitAgent, MCP server connections, faster harness, per-app database isolation, app renaming | | [v2.0.2](/changelog/v2-0-2) | July 2, 2026 | Artifacts in Build Mode, branch switching, environment variables, longer-lived sandbox | | [v2.0.1](/changelog/v2-0-1) | June 25, 2026 | Re-deploy control, stop button in planning mode, smarter agent patching, chat stability | | [v2.0.0](/changelog/v2-0-0) | June 18, 2026 | Full UI revamp, brainstorming & planning mode, custom brand themes | # v2.0.0 — June 18, 2026 Source: https://docs.architect.new/changelog/v2-0-0 A major release — full UI revamp, planning mode, custom themes, and stability wins. A big one — a full UI revamp, [brainstorming & planning mode](/build/planning-brainstorming), [custom brand themes](/build/custom-theme), and major stability wins across preview, [GitHub sync](/build/github-connect), and tool connections. ## New **A completely redesigned Architect.** We've rebuilt the entire interface from the ground up. It's cleaner, easier to navigate, and a lot nicer to look at — the same Architect, with a sharper, more modern feel throughout. See [How It Works](/introduction/platform/how-it-works). **Brainstorming & planning mode.** Before Architect writes a single line of code, you can now think the app through with it. Brainstorm the idea, shape the plan, and preview how the finished app will look with an interactive app mockup — all before anything is built. Planning mode can also produce a PRD, a PDF or slide deck, workflow diagrams, reusable skills, and starter files, then hand all of it to the build so your app starts with real context. → [Planning & Brainstorming](/build/planning-brainstorming) Planning mode showing an interactive app mockup alongside the plan, workflow diagram, and skill files **Bring your own design system.** Build a custom theme from your brand's design guidelines by pasting a design doc, importing from Figma, connecting a GitHub repo, or uploading a ZIP. Add your own design instructions and assets (like your logo), and Architect applies that look consistently across every app you build. → [Bring Your Own Design System](/build/custom-theme) The custom theme editor with a live preview of components, text, and the color palette **Plan mode while you iterate.** Planning isn't just for the first build. Once your app exists, toggle between Plan and Build mode to map out a change before Architect makes it — so bigger edits land exactly the way you intended. → [Plan Mode](/build/plan-mode) ## Improvements * **Polished, modern app design.** The apps Architect builds now ship with a more refined default design — improved layouts, spacing, and visual hierarchy out of the box, with no extra effort from you. * **Smarter GitHub sync and steadier deploys.** Connect your app to a GitHub repo and move fluidly across both. Make changes locally and Architect can pull the latest code and pick up where you left off — even recovering from local slip-ups like broken dependencies, a changed port, or build errors, then showing the working app back in preview. Deployments are more stable, too. → [Connecting Your GitHub](/build/github-connect) · [Deployment](/build/deployment) * **Seamless tool connections.** Connecting tools through Studio is now smooth and reliable. We reworked the connection flow to remove the errors that could happen while linking a tool to your app. → [Integrations](/integrations/custom-tools/custom-tools) ## Fixes * **A more stable preview sandbox.** We fixed the issues behind preview errors, so your app's live preview stays stable while you build. (Sandboxes still pause after a period of inactivity — but without the preview errors you used to see.) # v2.0.1 — June 25, 2026 Source: https://docs.architect.new/changelog/v2-0-1 Re-deploy control, smarter agent patching, and chat stability. Publish on your own terms, let Architect see your manual Studio edits, and get a chat experience that just works. ## New **Re-deploy when you're ready.** Once your app is deployed, Architect no longer re-deploys automatically on every iteration. Finish your changes, check the live preview, and press **Re-deploy** when you're happy with what you see — so only the work you've signed off on goes live. → [Deployment](/build/deployment) Re-deploy button in the Architect toolbar **Stop button in planning mode.** Made a mistake in your prompt mid-plan? Hit the new **Stop** button to cancel the current planning run and start fresh — without waiting for it to finish. Stop button in the planning mode chat toolbar ## Improvements **Architect now sees your manual Studio edits.** If you've adjusted agent instructions directly in Lyzr Studio and then continue iterating in Architect, Architect picks up those changes automatically. On top of that, instead of overwriting your entire agent instructions, it now patches only the specific parts it actually needs to change — so your manual customisations survive the next build iteration. ## Fixes * **App thumbnails now stay current.** Screenshots shown in the **My Apps** section now update whenever you iterate on an app, so you always see the latest version of your app — not the first one. * **Chat reliability overhaul.** Resolved a set of issues that caused chats to get stuck, show duplicate messages, disappear, or behave erratically while scrolling. Chat should now be solid end to end. * **Large file + image uploads no longer break the session.** Fixed a 32 MB payload limit that was hit when uploading many files or images in the Architect chat, causing the session to fail. # v2.0.2 — July 2, 2026 Source: https://docs.architect.new/changelog/v2-0-2 Artifacts in Build Mode, branch switching, environment variables, a longer-lived sandbox, and self-healing error fixes. More control over how you build, how you sync with GitHub, and how you connect your own tools — plus a sandbox that stays alive longer and fewer errors you ever need to touch. ## New **Create artifacts while you build.** You can now ask Architect to generate standalone documents right inside Build Mode — feature spec PDFs, use case presentations, research docs, HTML or Word documents — anything related to the app you're working on. They appear in the **Artifacts tab** in the right panel, ready to view or download. → [Creating Artifacts](/build/artifacts) Artifacts tab in Architect Build Mode showing a Feature Spec PDF Artifact document open in the Architect right panel **Branch switching for GitHub.** You can now check out to any branch of your connected GitHub repo and have Architect build in that branch. Create a branch locally (e.g. a `dev` branch), push it to GitHub, and switch to it from the GitHub panel in Architect — it pulls the latest code from that branch and continues from there. Work on separate features or experiments in parallel, each in its own branch. Pull and push controls are also available for explicit syncing in either direction. → [Connecting Your GitHub](/build/github-connect) Pull, Push and branch switcher controls in the Architect GitHub panel **Environment variables.** You can now add your own API keys and secrets directly to any Architect-built app via the **Environment variables** panel (⋮ menu → Environment variables). Add a key, then ask Architect to wire it up — for example, bring your own OpenAI key for Whisper transcription, connect an external database, or link any third-party service your app needs. → [Environment Variables](/build/environment-variables) Environment Variables option in the Architect app menu Environment variables panel showing name and value fields ## Improvements **Sandbox stays active for 10 minutes.** Your app preview sandbox now stays alive for at least 10 minutes, even if you step away from the screen. Previously the sandbox could die during short breaks, forcing you to refresh and wait for it to recover. Now it holds on long enough that you can come back and pick up right where you left off. ## Fixes **Architect self-heals most build errors automatically.** When an error occurs during a build — like a `500 error` on `/api/agent` — Architect now fixes it on its own in most cases without you having to click the **"Help me fix it"** prompt. The prompt still appears for edge cases that need your input, but the vast majority of common errors are resolved silently before you even notice them. # v2.1.0 — July 27, 2026 Source: https://docs.architect.new/changelog/v2-1-0 GitAgent, MCP server connections, a faster and more stable harness, per-app database isolation, and app renaming. A big one — build **git-native agents**, connect **any MCP server**, and get stronger data isolation, a faster build engine, and easier app management. ## New **Build with GitAgent (Beta).** Architect can now create **git-native agents** — an agent whose identity, rules, skills, and memory live as versioned files in a GitHub repo you own, instead of a hosted Lyzr agent. While planning a new app, just tick the optional **"Build this using GitAgent"** option. → [GitAgent (Beta)](/build/git-agents) The optional 'Build this using GitAgent' choice in Architect's planning flow A GitAgent's detail panel in Architect showing its Soul, Rules, and Duties **Connect MCP servers.** Bring any **Model Context Protocol (MCP)** server into your app — connect it once in Lyzr Studio (or add one right from the build chat) and your agents can use its tools. Great for capabilities that aren't in the built-in integrations list, like DeepWiki or Parallel Search. → [Connecting MCP Servers](/integrations/custom-tools/mcp-servers) Naming a connected MCP server in an Architect build prompt **Rename your app.** You can now rename an app for easier identification — click the **pencil icon** next to the app name, type a clear, descriptive name, and hit **Save**, so it's simple to find and recognize in **My Apps**. Rename app popover next to the app name in the Architect build view ## Improvements **Faster, more stable builds.** The in-sandbox harness — the engine that writes your app — got significant **speed and stability** improvements. Builds respond quicker and run with fewer interruptions. ## Security **Per-app database isolation.** Each app now gets its **own dedicated database**. Your data access is scoped to a single app, so records from one app can never be reached by another — a stronger boundary around every app's data. → [Database & Authentication](/build/database-auth) Each Architect app gets its own isolated database # v2.2.0 — August 7, 2026 Source: https://docs.architect.new/changelog/v2-2-0 A testing agent that tests and fixes your app for you, deploy without connecting GitHub, import a GitHub repo to keep building, rename your deployed URL, a detailed per-agent credit breakdown, and more reliable previews. This release makes Architect **more autonomous and more reliable** — it can now test and fix your app on its own, deploy without a GitHub account, import an existing repo to continue building, and show you exactly where your credits go. ## New **Added a testing agent that automatically tests and fixes the issues in your app.** Turn on **Test** in the chat composer and the agent verifies your app in a real browser after each build, catches the runtime and console errors you'd otherwise run into, and **fixes them on its own** — so you no longer have to spot an issue and prompt Architect to fix it. The app you get back has already been checked. *(Adds \~2–5 minutes per build; toggle it off anytime.)* Enabling the Test option in Architect's chat composer Architect's testing agent verifying a build and fixing errors on its own **Deploy without connecting GitHub.** You can now deploy immediately — **no GitHub account required.** Architect provisions and manages the repository for you using its own platform GitHub. Prefer to own the code? Use **Export to my GitHub** to move a platform-managed app into your own account whenever you like, and repositories are cleaned up automatically when an app is deleted. Deploying an Architect app without connecting a personal GitHub account **Import a GitHub repo and keep building.** Already have a **Next.js** project? Import any GitHub repository into Architect and continue building on it with Architect's agents — no need to start from scratch. Architect brings your codebase into a fresh workspace so you can iterate, add agents, and deploy from there. Selecting a GitHub repository to import into Architect Configuring a GitHub repository import in Architect Continuing to build on an imported GitHub repository in Architect **Rename your deployed app's URL.** Give your deployed app a **custom, memorable subdomain** instead of the auto-generated one. Pick a name that's on-brand; Architect checks that it's available and updates your app's live URL. Renaming a deployed app's URL in Architect **See exactly where your credits go.** Usage now includes a **detailed, per-agent breakdown** of what each build consumed — across **Plan**, **Agent Creator**, **UI Generation**, **Build**, and **Testing** — alongside a token breakdown (input / output / cached) and your run and lifetime totals. The figures come straight from the sandbox's credit ledger with your billing rate applied, so what you see matches what you're charged. Per-agent credit and token breakdown in Architect's usage panel ## Improvements **More reliable previews & sandboxes.** We've hardened the environment that runs your live preview and fixed the most common ways it used to break — previews stuck on **"Connection lost,"** **401 / "invalid sandbox"** errors, and apps **not serving on their preview port**. An app is now marked ready only once its preview actually loads (no more false "ready"), a momentary control-plane hiccup is treated as a transient blip rather than a crash, and your app keeps running through stray restarts — so previews come up cleanly and stay up. **Your PRD stays in sync on every iteration.** The plan document now updates as you build. Each time you refine your app, Architect rewrites and persists the **PRD** to reflect the change — so the plan always mirrors the current state of your app, and every iteration carries accurate context. **A more polished Architect, and better-looking apps.** We've refined Architect's overall look and feel, improved the visual quality of the apps it generates, and made the build chat more stable. # Gmail Source: https://docs.architect.new/integrations/communication/gmail The Gmail tool turns your AI agents into autonomous communicators. By integrating Gmail, your Architect applications can read incoming emails, draft hyper-personalized responses, organize your inbox, and send automated outbound campaigns on your behalf. ## Why Use Gmail in Architect? Email automation usually requires complex API setups and rigid templates. With Architect's vibe coding, you just describe the communication workflow you want. The AI uses the Gmail tool to dynamically craft context-aware emails and handle routing logic instantly. * **Intelligent Triage:** Build an agent that reads your inbox, categorizes emails by urgency, and drafts suggested replies for the important ones. * **Automated Outreach:** Pair Gmail with data tools to autonomously send highly personalized cold emails to targeted leads. * **Workflow Alerts:** Have your internal tools automatically email specific team members when certain conditions are met, completely hands-free. ## Vibe Coding Examples Try these natural language prompts to build intelligent email agents: "Build a customer support agent. Have it monitor my support inbox using the Gmail tool. If an email is a refund request, automatically reply asking for their order number. If it's a technical issue, forward it to [tech-support@company.com](mailto:tech-support@company.com)." "Create a daily reporting app. Every morning at 8 AM, fetch the latest news on 'Artificial Intelligence', format it into a beautifully styled HTML newsletter, and use the Gmail tool to send it to my mailing list." "I want an assistant for my personal inbox. Read every new email. If the sender's domain matches one of my VIP clients, immediately reply saying 'I have received your email and am reviewing it now,' and send me an urgent SMS alert." Vibe code a powerhouse sales agent by combining the Apollo tool (to find leads) and the Gmail tool (to email them) in a single prompt! ## Available Actions The Gmail tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `GMAIL_SEND_EMAIL` * `GMAIL_DRAFTS_CREATE` * `GMAIL_DRAFTS_GET` * `GMAIL_DRAFTS_LIST` * `GMAIL_DRAFTS_UPDATE` * `GMAIL_DRAFTS_SEND` * `GMAIL_DRAFTS_DELETE` * `GMAIL_MESSAGES_LIST` * `GMAIL_MESSAGES_GET` * `GMAIL_MESSAGES_MODIFY` * `GMAIL_MESSAGES_TRASH` * `GMAIL_MESSAGES_UNTRASH` * `GMAIL_LABELS_LIST` * `GMAIL_LABELS_GET` * `GMAIL_LABELS_CREATE` * `GMAIL_LABELS_UPDATE` * `GMAIL_LABELS_DELETE` * `GMAIL_THREADS_LIST` * `GMAIL_THREADS_GET` * `GMAIL_THREADS_MODIFY` * `GMAIL_THREADS_TRASH` * `GMAIL_THREADS_UNTRASH` * `GMAIL_THREADS_DELETE` # Instantly Source: https://docs.architect.new/integrations/communication/instantly The Instantly tool supercharges your AI agents for cold email outreach and B2B sales. By integrating Instantly into Architect, your apps can autonomously add leads to campaigns, analyze email replies, and manage outbound sales at scale. ## Why Use Instantly in Architect? Running outbound campaigns requires constantly moving data between lead databases, CRMs, and sending tools. With vibe coding, your AI acts as an autonomous Sales Development Rep (SDR). You describe your target audience and outreach strategy, and your agent orchestrates the entire pipeline. * **Automated Lead Injection:** Have your agent fetch new prospects from a database and automatically push them into an active Instantly campaign. * **Reply Sentiment Analysis:** Build apps that read incoming campaign replies in Instantly, determine if the prospect is interested, out of office, or angry, and categorize them accordingly. * **Campaign Reporting:** Create tools that check Instantly's analytics (open rates, reply rates) and send a weekly performance brief to your sales team. ## Vibe Coding Examples Try these natural language prompts to build autonomous sales agents: "Build an outbound sales pipeline. Read the 'New Leads' Google Sheet. For every new row, use the Instantly tool to add the contact's email and first name into my 'Q4 Outreach' campaign." "Create a campaign manager agent. Monitor replies in my Instantly campaigns. If a prospect replies with 'unsubscribe' or 'not interested', automatically mark them as 'Do Not Contact'. If they ask for a meeting, tag them as 'Interested' and alert me." "I want a sales analytics bot. Every Friday afternoon, use the Instantly tool to fetch the open rate and reply rate for my top 3 active campaigns. Format this into a brief report and highlight which campaign is performing the best." Vibe code the ultimate SDR! Prompt your agent to use Apollo to find leads, Instantly to email them, and HubSpot to log the interested replies as deals in your pipeline. ## Available Actions The Instantly tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `INSTANTLY_CHECK_EMAIL_VERIFICATION_STATUS` * `INSTANTLY_COUNT_UNREAD_EMAILS` * `INSTANTLY_CREATE_AI_ENRICHMENT` * `INSTANTLY_CREATE_API_KEY` * `INSTANTLY_CREATE_CAMPAIGN` * `INSTANTLY_CREATE_INBOX_PLACEMENT_TEST` * `INSTANTLY_CREATE_LEAD` * `INSTANTLY_CREATE_LEAD_LIST` * `INSTANTLY_CREATE_WEBHOOK` * `INSTANTLY_DELETE_API_KEY` * `INSTANTLY_DELETE_CAMPAIGN` * `INSTANTLY_DELETE_LEAD` * `INSTANTLY_DELETE_LEAD_LIST` * `INSTANTLY_DELETE_WEBHOOK` * `INSTANTLY_DISABLE_ACCOUNT_WARMUP` * `INSTANTLY_ENABLE_ACCOUNT_WARMUP` * `INSTANTLY_GET_CAMPAIGN` * `INSTANTLY_GET_CAMPAIGN_ANALYTICS` * `INSTANTLY_GET_DAILY_CAMPAIGN_ANALYTICS` * `INSTANTLY_GET_EMAIL_SERVICE_PROVIDER_OPTIONS` * `INSTANTLY_GET_INBOX_PLACEMENT_TEST` * `INSTANTLY_GET_LEAD` * `INSTANTLY_GET_LEAD_LIST` * `INSTANTLY_GET_VERIFICATION_STATS_FOR_LEAD_LIST` * `INSTANTLY_GET_WEBHOOK` * `INSTANTLY_GET_WEBHOOK_EVENT` * `INSTANTLY_LIST_ACCOUNTS` * `INSTANTLY_LIST_API_KEYS` * `INSTANTLY_LIST_CAMPAIGNS` * `INSTANTLY_LIST_CUSTOM_TAGS` * `INSTANTLY_LIST_DFY_EMAIL_ACCOUNT_ORDERS` * `INSTANTLY_LIST_EMAILS` * `INSTANTLY_LIST_INBOX_PLACEMENT_BLACKLIST_AND_SPAM_ASSASSIN_REPORTS` * `INSTANTLY_LIST_INBOX_PLACEMENT_TESTS` * `INSTANTLY_LIST_LEAD_LISTS` * `INSTANTLY_LIST_LEADS` * `INSTANTLY_LIST_THREADS` * `INSTANTLY_LIST_WEBHOOK_EVENTS` * `INSTANTLY_LIST_WEBHOOKS` * `INSTANTLY_MARK_THREAD_AS_READ` * `INSTANTLY_MERGE_LEADS` * `INSTANTLY_SEARCH_CAMPAIGNS_BY_LEAD_EMAIL` * `INSTANTLY_UPDATE_CAMPAIGN` * `INSTANTLY_UPDATE_LEAD` * `INSTANTLY_UPDATE_LEAD_INTEREST_STATUS` * `INSTANTLY_UPDATE_LEAD_LIST` * `INSTANTLY_VERIFY_EMAIL` # LinkedIn Source: https://docs.architect.new/integrations/communication/linkedin The LinkedIn tool empowers your AI agents to handle professional networking, social selling, and brand building. By integrating LinkedIn into Architect, your apps can autonomously draft posts, analyze profiles, and monitor industry trends. ## Why Use LinkedIn in Architect? Building a professional brand takes consistent effort. With Architect's vibe coding, your AI acts as a dedicated ghostwriter and networking assistant. You can describe your professional voice or target audience, and your agent will handle the heavy lifting of content creation and profile research. * **Automated Posting:** Build agents that read your company's latest blog posts or press releases and automatically draft and publish optimized LinkedIn updates. * **Profile Summarization:** Have your agent extract data from a prospect's LinkedIn profile and generate a personalized "icebreaker" for your sales calls. * **Trend Monitoring:** Create bots that track specific industry keywords on LinkedIn and summarize the top discussions to keep you informed. ## Vibe Coding Examples Try these natural language prompts to build autonomous professional networking agents: "Build a personal branding app. When I input a random thought or brief note, expand it into an engaging, professional LinkedIn post. Add relevant hashtags, format it with clean line breaks, and use the LinkedIn tool to publish it." "Create a sales prep bot. Before my meetings, I will provide a prospect's LinkedIn URL. Use the LinkedIn tool to analyze their recent job history and posts, and generate a 3-bullet summary of what they care about." "I want a corporate marketing agent. Whenever our engineering team publishes a new release note in Confluence, use the LinkedIn tool to post a summary of the new features to our official company page." Combine LinkedIn with Twitter/X! Vibe code an agent that takes a single idea and automatically formats it as a short tweet for Twitter/X and a longer, detailed article post for LinkedIn. ## Available Actions The LinkedIn tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `LINKEDIN_CREATE_LINKED_IN_POST` * `LINKEDIN_DELETE_LINKED_IN_POST` * `LINKEDIN_GET_COMPANY_INFO` * `LINKEDIN_GET_MY_INFO` # Microsoft Teams Source: https://docs.architect.new/integrations/communication/microsoft-teams The Microsoft Teams tool integrates your AI agents directly into your enterprise communication hub. By connecting Teams to Architect, your apps can autonomously send direct messages, post announcements in channels, format rich adaptive cards, and alert personnel instantly. ## Why Use Microsoft Teams in Architect? Keeping everyone in the loop often requires endless tab-switching and manual copy-pasting. With vibe coding, your AI acts as the ultimate enterprise dispatcher. You can describe complex notification workflows, and your agent will ensure the right people get the right information exactly when they need it, right where they already work. * **Automated Alerting:** Build server monitoring or finance apps that instantly ping the IT or Finance channels in Teams if an anomaly is detected. * **Daily Briefings:** Create an agent that compiles data overnight and posts a beautifully formatted summary card into the leadership channel every morning at 8 AM. * **Workflow Hand-offs:** Have your agent finish a complex task—like generating a legal contract—and immediately DM the reviewing manager in Teams with the file link. ## Vibe Coding Examples Try these natural language prompts to build integrated communication agents: "Build a customer support escalation bot. If a user submits a support ticket with the word 'Urgent' or 'Outage', use the Microsoft Teams tool to immediately post an alert in the 'Engineering-OnCall' channel and tag the channel members." "Create a sales celebration app. Whenever a deal is marked as 'Closed Won' in our CRM, use the Microsoft Teams tool to post a congratulatory message in the 'Sales-General' channel, including the deal amount and the salesperson's name." "I want an onboarding workflow. When a new employee is added to the system, automatically generate a welcome checklist document. Then, use the Microsoft Teams tool to send a direct message to the new employee welcoming them and attaching the checklist." Vibe code an end-to-end task manager! Tell Architect to create a ticket using Linear, update the project timeline in Asana, and finally announce the new feature rollout in Microsoft Teams! ## Available Actions The Microsoft Teams tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `MICROSOFT_TEAMS_ADD_MEMBER_TO_TEAM` * `MICROSOFT_TEAMS_ARCHIVE_TEAM` * `MICROSOFT_TEAMS_CHATS_GET_ALL_CHATS` * `MICROSOFT_TEAMS_CHATS_GET_ALL_MESSAGES` * `MICROSOFT_TEAMS_CREATE_MEETING` * `MICROSOFT_TEAMS_CREATE_TEAM` * `MICROSOFT_TEAMS_DELETE_TEAM` * `MICROSOFT_TEAMS_GET_CHANNEL` * `MICROSOFT_TEAMS_GET_CHAT_MESSAGE` * `MICROSOFT_TEAMS_GET_TEAM` * `MICROSOFT_TEAMS_LIST_MESSAGE_REPLIES` * `MICROSOFT_TEAMS_LIST_TEAM_MEMBERS` * `MICROSOFT_TEAMS_LIST_TEAMS_TEMPLATES` * `MICROSOFT_TEAMS_LIST_USERS` * `MICROSOFT_TEAMS_TEAMS_CREATE_CHANNEL` * `MICROSOFT_TEAMS_TEAMS_CREATE_CHAT` * `MICROSOFT_TEAMS_TEAMS_GET_MESSAGE` * `MICROSOFT_TEAMS_TEAMS_LIST` * `MICROSOFT_TEAMS_TEAMS_LIST_CHANNELS` * `MICROSOFT_TEAMS_TEAMS_LIST_CHAT_MESSAGES` * `MICROSOFT_TEAMS_TEAMS_LIST_PEOPLE` * `MICROSOFT_TEAMS_TEAMS_POST_CHANNEL_MESSAGE` * `MICROSOFT_TEAMS_TEAMS_POST_CHAT_MESSAGE` * `MICROSOFT_TEAMS_TEAMS_POST_MESSAGE_REPLY` * `MICROSOFT_TEAMS_UNARCHIVE_TEAM` * `MICROSOFT_TEAMS_UPDATE_CHANNEL_MESSAGE` * `MICROSOFT_TEAMS_UPDATE_CHAT_MESSAGE` * `MICROSOFT_TEAMS_UPDATE_TEAM` # Slack Source: https://docs.architect.new/integrations/communication/slack The Slack tool brings your AI agents directly into your team's central nervous system. By connecting Slack to Architect, your apps can autonomously monitor channels, send direct messages, alert specific groups, and summarize lengthy discussion threads. ## Why Use Slack in Architect? Context switching kills productivity. With vibe coding, your AI agents act as invisible team members that handle the busywork. Instead of opening dashboards to check stats or building complex webhooks, you just describe the notifications you want, and your agent pushes the right information to the right Slack channel instantly. * **Automated Dispatch:** Build alerting systems that immediately ping the #engineering channel when a critical server error is logged. * **Intelligent Summaries:** Create agents that read a chaotic, 50-message Slack thread and output a clean, 3-bullet-point summary of the final decisions. * **Workflow Triggers:** Have your internal tools notify managers for approval via DM the moment a new expense report is filed. ## Vibe Coding Examples Try these natural language prompts to build autonomous Slack agents: "Build a sales notification app. When a new contract is signed, use the Slack tool to post a celebratory message in the #sales-wins channel. Include the client's name, the deal size, and the `@username` of the rep who closed it." "Create a feedback processor. Monitor incoming user reviews. If a review is negative and mentions 'bug' or 'crash', use the Slack tool to send an alert to the #product-triage channel with a summary of the complaint." "I want an executive assistant bot. At 5:00 PM every day, compile the top 3 completed tasks from our project board and use the Slack tool to send me a direct message summarizing the day's progress." Vibe code an entire support pipeline! Prompt your agent to use Gmail to read an angry customer email, use HubSpot to look up their account tier, and use Slack to instantly alert the VIP Support team! ## Available Actions The Slack tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `SLACK_ACTIVATE_OR_MODIFY_DO_NOT_DISTURB_DURATION` * `SLACK_ADD_A_CUSTOM_EMOJI_TO_A_SLACK_TEAM` * `SLACK_ADD_AN_EMOJI_ALIAS_IN_SLACK` * `SLACK_ADD_A_REMOTE_FILE_FROM_A_SERVICE` * `SLACK_ADD_A_STAR_TO_AN_ITEM` * `SLACK_ADD_CALL_PARTICIPANTS` * `SLACK_ADD_EMOJI` * `SLACK_ADD_REACTION_TO_AN_ITEM` * `SLACK_ARCHIVE_A_PUBLIC_OR_PRIVATE_CHANNEL` * `SLACK_ARCHIVE_A_SLACK_CONVERSATION` * `SLACK_CHAT_POST_MESSAGE` * `SLACK_CLOSE_DM_OR_MULTI_PERSON_DM` * `SLACK_CREATE_A_REMINDER` * `SLACK_CREATE_A_SLACK_USER_GROUP` * `SLACK_CREATE_CHANNEL` * `SLACK_CREATE_CHANNEL_BASED_CONVERSATION` * `SLACK_CUSTOMIZE_URL_UNFURL` * `SLACK_CUSTOMIZE_URL_UNFURLING_IN_MESSAGES` * `SLACK_DELETE_A_COMMENT_ON_A_FILE` * `SLACK_DELETE_A_FILE_BY_ID` * `SLACK_DELETE_A_PUBLIC_OR_PRIVATE_CHANNEL` * `SLACK_DELETE_A_SCHEDULED_MESSAGE_IN_A_CHAT` * `SLACK_DELETE_A_SLACK_REMINDER` * `SLACK_DELETES_A_MESSAGE_FROM_A_CHAT` * `SLACK_DELETE_USER_PROFILE_PHOTO` * `SLACK_DISABLE_AN_EXISTING_SLACK_USER_GROUP` * `SLACK_ENABLE_A_SPECIFIED_USER_GROUP` * `SLACK_ENABLE_PUBLIC_SHARING_OF_A_FILE` * `SLACK_END_A_CALL_WITH_DURATION_AND_ID` * `SLACK_END_SNOOZE` * `SLACK_END_USER_DO_NOT_DISTURB_SESSION` * `SLACK_END_USER_SNOOZE_MODE_IMMEDIATELY` * `SLACK_FETCH_BOT_USER_INFORMATION` * `SLACK_FETCH_CONVERSATION_HISTORY` * `SLACK_FETCH_CURRENT_TEAM_INFO_WITH_OPTIONAL_TEAM_SCOPE` * `SLACK_FETCH_DND_STATUS_FOR_MULTIPLE_TEAM_MEMBERS` * `SLACK_FETCH_ITEM_REACTIONS` * `SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION` * `SLACK_FETCH_TEAM_INFO` * `SLACK_FETCH_WORKSPACE_SETTINGS_INFORMATION` * `SLACK_FIND_CHANNELS` * `SLACK_FIND_USER_BY_EMAIL_ADDRESS` * `SLACK_FIND_USERS` * `SLACK_GET_CHANNEL_CONVERSATION_PREFERENCES` * `SLACK_GET_REMINDER_INFORMATION` * `SLACK_GET_REMOTE_FILE` * `SLACK_GET_TEAM_DND_STATUS` * `SLACK_GET_USER_PRESENCE_INFO` * `SLACK_INITIATES_CHANNEL_BASED_CONVERSATIONS` * `SLACK_INVITE_USERS_TO_A_SLACK_CHANNEL` * `SLACK_INVITE_USER_TO_CHANNEL` * `SLACK_INVITE_USER_TO_WORKSPACE` * `SLACK_INVITE_USER_TO_WORKSPACE_WITH_OPTIONAL_CHANNEL_INVITES` * `SLACK_JOIN_AN_EXISTING_CONVERSATION` * `SLACK_LEAVE_A_CONVERSATION` * `SLACK_LIST_ACCESSIBLE_CONVERSATIONS_FOR_A_USER` * `SLACK_LIST_ALL_CHANNELS` * `SLACK_LIST_ALL_SLACK_TEAM_CHANNELS_WITH_VARIOUS_FILTERS` * `SLACK_LIST_ALL_SLACK_TEAM_USERS_WITH_PAGINATION` * `SLACK_LIST_ALL_USERS` * `SLACK_LIST_ALL_USERS_IN_A_USER_GROUP` * `SLACK_LIST_CONVERSATIONS` * `SLACK_LIST_FILES_WITH_FILTERS_IN_SLACK` * `SLACK_LIST_REMINDERS` * `SLACK_LIST_REMOTE_FILES` * `SLACK_LIST_SCHEDULED_MESSAGES` * `SLACK_LIST_SCHEDULED_MESSAGES_IN_A_CHANNEL` * `SLACK_LIST_SLACK_S_REMOTE_FILES_WITH_FILTERS` * `SLACK_LISTS_PINNED_ITEMS_IN_A_CHANNEL` * `SLACK_LIST_STARRED_ITEMS` * `SLACK_LISTS_USER_S_STARRED_ITEMS_WITH_PAGINATION` * `SLACK_LIST_TEAM_CUSTOM_EMOJIS` * `SLACK_LIST_USER_GROUPS_FOR_TEAM_WITH_OPTIONS` * `SLACK_LIST_USER_REACTIONS` * `SLACK_LIST_USER_REMINDERS_WITH_DETAILS` * `SLACK_LIST_WORKSPACE_USERS` * `SLACK_MANUALLY_SET_USER_PRESENCE` * `SLACK_MARK_REMINDER_AS_COMPLETE` * `SLACK_OPEN_DM` * `SLACK_OPEN_OR_RESUME_DIRECT_OR_MULTI_PERSON_MESSAGES` * `SLACK_PINS_AN_ITEM_TO_A_CHANNEL` * `SLACK_REGISTER_CALL_PARTICIPANTS_REMOVAL` * `SLACK_REGISTERS_A_NEW_CALL_WITH_PARTICIPANTS` * `SLACK_REGISTERS_NEW_CALL_PARTICIPANTS` * `SLACK_REMOVE_A_REMOTE_FILE` * `SLACK_REMOVE_A_STAR_FROM_AN_ITEM` * `SLACK_REMOVE_A_USER_FROM_A_CONVERSATION` * `SLACK_REMOVE_CALL_PARTICIPANTS` * `SLACK_REMOVE_REACTION_FROM_ITEM` * `SLACK_RENAME_A_CONVERSATION` * `SLACK_RENAME_AN_EMOJI` * `SLACK_RENAME_A_SLACK_CHANNEL` * `SLACK_RETRIEVE_A_USER_S_IDENTITY_DETAILS` * `SLACK_RETRIEVE_CALL_INFORMATION` * `SLACK_RETRIEVE_CONVERSATION_INFORMATION` * `SLACK_RETRIEVE_CONVERSATION_MEMBERS_LIST` * `SLACK_RETRIEVE_CURRENT_USER_DND_STATUS` * `SLACK_RETRIEVE_DETAILED_INFORMATION_ABOUT_A_FILE` * `SLACK_RETRIEVE_DETAILED_USER_INFORMATION` * `SLACK_RETRIEVE_MESSAGE_PERMALINK_URL` # Telegram Source: https://docs.architect.new/integrations/communication/telegram The Telegram tool allows your AI agents to send blazing-fast notifications and messages directly to your phone or community groups. By connecting Telegram to Architect, your apps can operate as personal pocket assistants or autonomous group moderators. ## Why Use Telegram in Architect? Sometimes you need alerts immediately, without logging into a heavy enterprise platform. With Architect's vibe coding, you can quickly spin up lightweight bots that talk directly to you on Telegram. It’s perfect for personal alerting, community management, or sending on-the-go workflow updates. * **Personal Alerting:** Build agents that act as your personal radar, sending you a Telegram message the second a specific client emails you or a server goes down. * **Community Moderation:** Create bots that monitor Telegram group chats for spam, welcome new members, and answer frequently asked questions autonomously. * **On-the-Go Reporting:** Have your agent fetch daily financial metrics or crypto prices and send you a formatted morning brief directly to your phone. ## Vibe Coding Examples Try these natural language prompts to build instant-messaging agents: "Build a personal alert app. Monitor my support inbox. If an email comes in from '[investor@company.com](mailto:investor@company.com)', immediately use the Telegram tool to send me a direct message containing the email subject line and a 1-sentence summary." "Create a community bot. When a new user joins my public Telegram group, use the Telegram tool to post a welcome message tagging them, outlining the group rules, and offering a brief summary of what the community discusses." "I want a daily digest agent. At 7:00 AM every day, fetch the top 3 tech news headlines. Format them nicely with bullet points and emojis, and use the Telegram tool to send the digest to my personal chat." Vibe code a research assistant for your commute! Have the agent use the Arxiv tool to find new papers on AI, summarize them, and send the summaries to your Telegram so you can read them on your phone. ## Available Actions The Telegram tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `TELEGRAM_ANSWER_CALLBACK_QUERY` * `TELEGRAM_DELETE_MESSAGE` * `TELEGRAM_EDIT_MESSAGE` * `TELEGRAM_EXPORT_CHAT_INVITE_LINK` * `TELEGRAM_FORWARD_MESSAGE` * `TELEGRAM_GET_CHAT` * `TELEGRAM_GET_CHAT_ADMINISTRATORS` * `TELEGRAM_GET_CHAT_HISTORY` * `TELEGRAM_GET_CHAT_MEMBERS_COUNT` * `TELEGRAM_GET_ME` * `TELEGRAM_GET_UPDATES` * `TELEGRAM_SEND_DOCUMENT` * `TELEGRAM_SEND_LOCATION` * `TELEGRAM_SEND_MESSAGE` * `TELEGRAM_SEND_PHOTO` * `TELEGRAM_SEND_POLL` * `TELEGRAM_SET_MY_COMMANDS` # Twitter/X Source: https://docs.architect.new/integrations/communication/twitter The Twitter/X tool transforms your AI agents into autonomous social media managers and social listening platforms. By integrating Twitter/X into Architect, your apps can autonomously craft viral threads, monitor brand mentions, analyze sentiment, and engage with your audience. ## Why Use Twitter/X in Architect? Managing a brand's social presence requires constant vigilance and content creation. With vibe coding, you can describe your ideal social media strategy, and your agent will execute it. Whether it's repurposing long-form content into engaging tweets, acting as a frontline support agent, or tracking industry trends, the Twitter/X tool puts your social strategy on autopilot. * **Automated Thread Generation:** Have your agent read a newly published blog post and instantly distill it into an engaging 5-part Twitter thread. * **Intelligent Social Listening:** Build apps that monitor the timeline for your brand name, analyze whether the sentiment is positive or negative, and flag urgent issues. * **Autonomous Engagement:** Create bots that reply to common customer support queries on Twitter immediately, providing helpful links without human intervention. ## Vibe Coding Examples Try these natural language prompts to build powerful social media agents: "Build a social media app. When I input a YouTube video transcript, extract the 3 most interesting quotes. Use the Twitter/X tool to draft three distinct tweets based on those quotes, complete with relevant hashtags, and post them." "Create a brand monitoring agent. Use the Twitter/X tool to fetch the last 50 tweets mentioning our company. Analyze the overall sentiment. If more than 20% of the tweets are highly negative, immediately alert the PR team." "I want an industry research bot. Every Friday, use the Twitter/X tool to search for the hashtag #ArtificialIntelligence. Read the top 20 most engaged tweets and generate a summary report of what the community is talking about this week." Vibe code an entire PR pipeline! Prompt your agent to use the Twitter/X tool to spot a customer complaint, use Linear to file a bug report, and use Slack to alert the engineering team! ## Available Actions The Twitter/X tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `TWITTER_ADD_A_LIST_MEMBER` * `TWITTER_ADD_POST_TO_BOOKMARKS` * `TWITTER_BOOKMARKS_BY_USER` * `TWITTER_CREATE_A_NEW_DM_CONVERSATION` * `TWITTER_CREATE_COMPLIANCE_JOB_REQUEST` * `TWITTER_CREATE_LIST` * `TWITTER_CREATION_OF_A_POST` * `TWITTER_DELETE_DM` * `TWITTER_DELETE_LIST` * `TWITTER_FETCH_LIST_MEMBERS_BY_ID` * `TWITTER_FETCH_SPACE_TICKET_BUYERS_LIST` * `TWITTER_FOLLOW_A_LIST` * `TWITTER_FOLLOWERS_BY_USER_ID` * `TWITTER_FOLLOWING_BY_USER_ID` * `TWITTER_FOLLOW_USER` * `TWITTER_FULL_ARCHIVE_SEARCH` * `TWITTER_FULL_ARCHIVE_SEARCH_COUNTS` * `TWITTER_GET_A_USER_S_LIST_MEMBERSHIPS` * `TWITTER_GET_A_USER_S_OWNED_LISTS` * `TWITTER_GET_A_USER_S_PINNED_LISTS` * `TWITTER_GET_BLOCKED_USERS` * `TWITTER_GET_DM_EVENTS_BY_ID` * `TWITTER_GET_DM_EVENTS_FOR_A_DM_CONVERSATION` * `TWITTER_GET_LIST_FOLLOWERS` * `TWITTER_GET_MUTED_USERS` * `TWITTER_GET_POST_RETWEETERS_ACTION` * `TWITTER_GET_RECENT_DM_EVENTS` * `TWITTER_GET_USER_S_FOLLOWED_LISTS` * `TWITTER_HIDE_REPLIES` * `TWITTER_LIST_LOOKUP_BY_LIST_ID` * `TWITTER_LIST_POST_LIKERS` * `TWITTER_LIST_POSTS_TIMELINE_BY_LIST_ID` * `TWITTER_MUTE_USER_BY_USER_ID` * `TWITTER_PIN_A_LIST` * `TWITTER_POST_DELETE_BY_POST_ID` * `TWITTER_POST_LOOKUP_BY_POST_ID` * `TWITTER_POST_LOOKUP_BY_POST_IDS` * `TWITTER_POSTS_LABEL_STREAM` * `TWITTER_POST_USAGE` * `TWITTER_RECENT_SEARCH` * `TWITTER_RECENT_SEARCH_COUNTS` * `TWITTER_REMOVE_A_BOOKMARKED_POST` * `TWITTER_REMOVE_A_LIST_MEMBER` * `TWITTER_RETRIEVE_COMPLIANCE_JOB_BY_ID` * `TWITTER_RETRIEVE_COMPLIANCE_JOBS` * `TWITTER_RETRIEVE_DM_CONVERSATION_EVENTS` * `TWITTER_RETRIEVE_POSTS_FROM_A_SPACE` * `TWITTER_RETRIEVE_POSTS_THAT_QUOTE_A_POST` * `TWITTER_RETRIEVE_POSTS_THAT_REPOST_A_POST` * `TWITTER_RETURNS_POST_OBJECTS_LIKED_BY_THE_PROVIDED_USER_ID` * `TWITTER_RETURNS_THE_OPEN_API_SPECIFICATION_DOCUMENT` * `TWITTER_RETWEET_POST` * `TWITTER_SEARCH_FOR_SPACES` * `TWITTER_SEND_A_NEW_MESSAGE_TO_A_DM_CONVERSATION` * `TWITTER_SEND_A_NEW_MESSAGE_TO_A_USER` * `TWITTER_SPACE_LOOKUP_BY_SPACE_ID` * `TWITTER_SPACE_LOOKUP_BY_THEIR_CREATORS` * `TWITTER_SPACE_LOOKUP_UP_SPACE_IDS` * `TWITTER_UNFOLLOW_A_LIST` * `TWITTER_UNFOLLOW_USER` * `TWITTER_UNLIKE_POST` * `TWITTER_UNMUTE_USER_BY_USER_ID` * `TWITTER_UNPIN_A_LIST` * `TWITTER_UNRETWEET_POST` * `TWITTER_UPDATE_LIST` * `TWITTER_USER_HOME_TIMELINE_BY_USER_ID` * `TWITTER_USER_LIKE_POST` * `TWITTER_USER_LOOKUP_BY_ID` * `TWITTER_USER_LOOKUP_BY_IDS` * `TWITTER_USER_LOOKUP_BY_USERNAME` * `TWITTER_USER_LOOKUP_BY_USERNAMES` * `TWITTER_USER_LOOKUP_ME` # Apollo Source: https://docs.architect.new/integrations/crm-data/apollo Apollo is a powerful B2B intelligence and lead generation database. By utilizing the Apollo tool within Lyzr Architect, you empower your AI agents to directly search for contacts, enrich company profiles, and discover precise lead information seamlessly. ## Why Use Apollo in Architect? Architect is built for vibe coding—you describe what you want, and the AI builds it. With the Apollo tool integrated, you don't need to worry about writing complex API requests or managing data pipelines to fetch B2B leads. You simply tell Architect that your app needs to find specific decision-makers or enrich company data, and the Apollo tool handles the heavy lifting in the background. * **Instant Lead Generation:** Transform a simple company name into a detailed list of executives and their contact info. * **Automated Enrichment:** Build apps that automatically flesh out sparse lead lists with deep company insights (funding, headcount, industry). * **No-Code Integrations:** Combine Apollo's data retrieval with email tools in a single vibe-coded prompt to create end-to-end sales agents. ## Vibe Coding Examples Here are a few ways you can prompt Architect to build powerful Apollo-enabled applications just by using natural language: "Build an AI sales assistant. It should take a target company's domain as input, use the Apollo tool to find the Chief Marketing Officer (CMO), and display their name and email." "Create a lead qualification app. I will provide a list of company names. Use Apollo to check each company's employee headcount and industry. If they are in software and have over 100 employees, mark them as 'Qualified'." "I want an agent for my outbound sales. It needs to accept a target company URL, use Apollo to find the VP of Sales, and then draft a highly personalized cold email tailored to that specific person." You can combine Apollo with other tools like Gmail or Slack in your vibe coding prompt to instantly send the leads you find directly to your team or your prospects! ## Available Actions The Apollo tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `APOLLO_ADD_CONTACTS_TO_SEQUENCE` * `APOLLO_BULK_ORGANIZATION_ENRICHMENT` * `APOLLO_BULK_PEOPLE_ENRICHMENT` * `APOLLO_BULK_UPDATE_ACCOUNT_STAGE` * `APOLLO_CREATE_ACCOUNT` * `APOLLO_CREATE_CONTACT` * `APOLLO_CREATE_DEAL` * `APOLLO_CREATE_TASK` * `APOLLO_GET_LABELS` * `APOLLO_GET_OPPORTUNITY_STAGES` * `APOLLO_GET_ORGANIZATION_JOB_POSTINGS` * `APOLLO_GET_TYPED_CUSTOM_FIELDS` * `APOLLO_LIST_ACCOUNT_STAGES` * `APOLLO_LIST_CONTACT_STAGES` * `APOLLO_LIST_DEALS` * `APOLLO_LIST_EMAIL_ACCOUNTS` * `APOLLO_LIST_USERS` * `APOLLO_ORGANIZATION_ENRICHMENT` * `APOLLO_ORGANIZATION_SEARCH` * `APOLLO_PEOPLE_ENRICHMENT` * `APOLLO_PEOPLE_SEARCH` * `APOLLO_SEARCH_ACCOUNTS` * `APOLLO_SEARCH_CONTACTS` * `APOLLO_SEARCH_SEQUENCES` * `APOLLO_SEARCH_TASKS` * `APOLLO_UPDATE_ACCOUNT` * `APOLLO_UPDATE_CONTACT` * `APOLLO_UPDATE_CONTACT_OWNERSHIP` * `APOLLO_UPDATE_CONTACT_STAGE` * `APOLLO_UPDATE_CONTACT_STATUS_IN_SEQUENCE` * `APOLLO_UPDATE_DEALS` # Freshdesk Source: https://docs.architect.new/integrations/crm-data/freshdesk The Freshdesk tool connects your AI agents directly to your customer support helpdesk. By integrating Freshdesk into Architect, your apps can autonomously read tickets, draft replies, categorize issues, and escalate critical bugs. ## Why Use Freshdesk in Architect? Customer support teams often spend too much time reading and routing tickets instead of solving them. With vibe coding, your AI acts as an autonomous Tier 1 support agent. You describe how different types of customer queries should be handled, and the Freshdesk tool automatically executes those workflows. * **Automated Ticket Triage:** Have your agent read incoming tickets, determine their urgency, assign the correct tags (e.g., 'Billing', 'Technical'), and route them to the appropriate agent. * **Suggested Replies:** Build apps that read complex customer issues, query your internal knowledge base, and draft a highly accurate response as a private note on the Freshdesk ticket. * **Sentiment Escalation:** Create bots that monitor ticket language for frustration and automatically escalate angry customers to a human manager. ## Vibe Coding Examples Try these natural language prompts to build autonomous customer support agents: "Build a support router. Read all new tickets in Freshdesk. If the ticket mentions 'refund' or 'cancel', assign it to the Billing team. If it mentions 'password' or 'login', assign it to Tier 1 Support and apply the 'Account Access' tag." "Create an autonomous support bot. When a user submits a ticket asking about our shipping policy, use the Freshdesk tool to instantly reply with a polite message containing our standard shipping timelines and close the ticket." "I want a priority support agent. Whenever a new ticket comes in, check the user's email domain. If it matches a list of our enterprise clients, use the Freshdesk tool to mark the ticket priority as 'Urgent' and send an alert to the Customer Success Manager." Combine Freshdesk with Linear! Vibe code an agent that reads a bug report in Freshdesk, creates a development ticket in Linear, and links the two together seamlessly. ## Available Actions The Freshdesk tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `FRESHDESK_CREATE_TICKET` * `FRESHDESK_DELETE_TICKET` * `FRESHDESK_GET_TICKETS` * `FRESHDESK_LIST_ALL_TICKETS` * `FRESHDESK_REPLY_TICKET` * `FRESHDESK_UPDATE_TICKET` * `FRESHDESK_VIEW_TICKET` # Google Sheets Source: https://docs.architect.new/integrations/crm-data/google-sheets The Google Sheets tool empowers your AI agents to interact directly with your cloud spreadsheets. By integrating Google Sheets, your Architect apps can autonomously read data, append rows, perform calculations, and manage live trackers. ## Why Use Google Sheets in Architect? Managing trackers and moving data between apps usually requires Zapier or complex scripts. With Architect's vibe coding, you simply tell your agent what data needs to go where. Your AI handles the logic, turning messy inputs into clean, organized rows in your Google Sheets. * **Automated Data Entry:** Have your agent parse incoming invoices, emails, or lead forms and automatically append new rows to your master tracking sheet. * **Live Reporting:** Build apps that scan thousands of rows of live data to spot anomalies or summarize weekly performance metrics. * **Dynamic Updates:** Create agents that search for specific rows (like a client's name) and update their status or subscription tier automatically. ## Vibe Coding Examples Try these natural language prompts to build autonomous spreadsheet agents: "Build a lead processing agent. When I receive an email from a potential client, extract their name, company, and budget, and use the Google Sheets tool to add a new row to our 'Q3 Leads' spreadsheet." "Create a finance bot. Once a week, read the 'Monthly Expenses' Google Sheet. If it spots any single expense over \$1000, flag the row and send a summary to the finance channel." "I want an inventory app. When a salesperson reports a closed deal, use the Google Sheets tool to find the sold item in the 'Inventory' sheet and reduce its available stock count by one." Vibe code a complete workflow! Have your agent use the Apollo tool to find new prospects, use Google Sheets to log their data, and use Gmail to send them a personalized outreach email. ## Available Actions The Google Sheets tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `GOOGLE_SHEETSVALUES_GET` * `GOOGLE_SHEETSVALUES_UPDATE` * `GOOGLE_SHEETSVALUES_BATCH_UPDATE` * `GOOGLE_SHEETSVALUES_APPEND` * `GOOGLE_SHEETS_SPREADSHEET_CREATE` # HubSpot Source: https://docs.architect.new/integrations/crm-data/hubspot The HubSpot tool integrates your AI agents directly into your Customer Relationship Management (CRM) system. By connecting HubSpot to Architect, your apps can autonomously create contacts, log meetings, update deal stages, and retrieve customer histories on demand. ## Why Use HubSpot in Architect? Sales and marketing teams lose hours every week to manual CRM data entry. With Architect's vibe coding, you can describe how data should flow into HubSpot, and the AI handles the rest. Your agent can listen to conversations, read emails, or process web forms, and immediately reflect those updates in your CRM without a single click. * **Zero-Touch Data Entry:** Have your agent automatically parse call transcripts and log detailed notes under the correct company record in HubSpot. * **Automated Deal Tracking:** Build apps that monitor email threads for buying signals and automatically move deals to the "Negotiation" stage. * **Instant Context:** Create internal chatbots that instantly pull up a client's entire HubSpot history when a support ticket is opened. ## Vibe Coding Examples Try these natural language prompts to build intelligent CRM agents: "Build a sales assistant. When I upload a meeting transcript, analyze it to identify the client's main pain points. Then, use the HubSpot tool to find their contact record and log a new meeting note containing this summary." "Create a lead generation bot. When I provide an email address and a company name, use the HubSpot tool to create a new Contact. If the company is not in the CRM, create a new Company record and associate the two." "I want an email monitoring agent. If a client replies to a proposal email with 'approved' or 'looks good', use the HubSpot tool to find their associated deal and automatically move its stage to 'Closed Won'." Vibe code an entire sales pipeline! Combine Apollo to find leads, Gmail to email them, and HubSpot to automatically log them as new contacts in your CRM! ## Available Actions The HubSpot tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `HUBSPOT_ADD_ASSET_ASSOCIATION` * `HUBSPOT_ADD_TOKEN_TO_EVENT_TEMPLATE` * `HUBSPOT_ARCHIVE` * `HUBSPOT_ARCHIVE_A_BATCH_OF_EMAILS_BY_ID` * `HUBSPOT_ARCHIVE_A_BATCH_OF_QUOTES_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_COMPANIES_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_CONTACTS_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_DEALS_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_FEEDBACK_SUBMISSIONS_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_LINE_ITEMS_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_OBJECTS_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_OF_PROPERTIES` * `HUBSPOT_ARCHIVE_BATCH_OF_TICKETS_BY_ID` * `HUBSPOT_ARCHIVE_BATCH_PRODUCTS_BY_ID` * `HUBSPOT_ARCHIVE_COMPANY` * `HUBSPOT_ARCHIVE_CONTACT_BY_ID` * `HUBSPOT_ARCHIVE_CRM_OBJECT_BY_ID` * `HUBSPOT_ARCHIVE_EMAILS` * `HUBSPOT_ARCHIVE_FEEDBACK_SUBMISSION` * `HUBSPOT_ARCHIVE_LINE_ITEM_BY_ID` * `HUBSPOT_ARCHIVE_PRODUCT` * `HUBSPOT_ARCHIVE_PRODUCT_BY_PRODUCT_ID` * `HUBSPOT_ARCHIVE_PRODUCTS` * `HUBSPOT_ARCHIVE_PROPERTY_BY_OBJECT_TYPE_AND_NAME` * `HUBSPOT_ARCHIVE_PROPERTY_GROUP` * `HUBSPOT_ARCHIVE_QUOTE_OBJECT_BY_ID` * `HUBSPOT_ARCHIVE_TICKET` * `HUBSPOT_ARCHIVE_TICKET_BY_ID` * `HUBSPOT_ARCHIVE_TICKETS` * `HUBSPOT_AUDIT_PIPELINE_CHANGES_BY_ID` * `HUBSPOT_BATCH_READ_COMPANIES_BY_PROPERTIES` * `HUBSPOT_BATCH_READ_EMAILS_ACTION` * `HUBSPOT_BATCH_UPDATE_QUOTES` * `HUBSPOT_CAMPAIGN_SEARCH` * `HUBSPOT_CANCEL_ACTIVE_IMPORT` * `HUBSPOT_CLONE_MARKETING_EMAIL` * `HUBSPOT_CONFIGURE_CALLING_EXTENSION_SETTINGS` * `HUBSPOT_CREATE` * `HUBSPOT_CREATE_A_BATCH_OF_CAMPAIGNS` * `HUBSPOT_CREATE_A_BATCH_OF_COMPANIES` * `HUBSPOT_CREATE_A_BATCH_OF_CONTACTS` * `HUBSPOT_CREATE_A_BATCH_OF_EMAILS` * `HUBSPOT_CREATE_AB_TEST_VARIATION` * `HUBSPOT_CREATE_A_CAMPAIGN` * `HUBSPOT_CREATE_AND_RETURN_A_NEW_PROPERTY_GROUP` * `HUBSPOT_CREATE_A_NEW_MARKETING_EMAIL` * `HUBSPOT_CREATE_ASSOCIATION_FOR_OBJECT_TYPE` * `HUBSPOT_CREATE_BATCH_OF_CONTACTS` * `HUBSPOT_CREATE_BATCH_OF_DEALS` * `HUBSPOT_CREATE_BATCH_OF_FEEDBACK_SUBMISSIONS` * `HUBSPOT_CREATE_BATCH_OF_LINE_ITEMS` * `HUBSPOT_CREATE_BATCH_OF_OBJECTS` * `HUBSPOT_CREATE_BATCH_OF_PROPERTIES` * `HUBSPOT_CREATE_BATCH_OF_QUOTES` * `HUBSPOT_CREATE_BATCH_OF_TICKET` * `HUBSPOT_CREATE_CAMPAIGN` * `HUBSPOT_CREATE_CAMPAIGNS` * `HUBSPOT_CREATE_COMPANY` * `HUBSPOT_CREATE_COMPANY_OBJECT` * `HUBSPOT_CREATE_CONTACT` * `HUBSPOT_CREATE_CONTACT_OBJECT_WITH_PROPERTIES` * `HUBSPOT_CREATE_CRM_OBJECT_WITH_PROPERTIES` * `HUBSPOT_CREATE_DEAL` * `HUBSPOT_CREATE_EMAIL` * `HUBSPOT_CREATE_EMAILS` * `HUBSPOT_CREATE_EVENT_TEMPLATE_FOR_APP` * `HUBSPOT_CREATE_FEEDBACK_SUBMISSION` * `HUBSPOT_CREATE_LINE_ITEM` * `HUBSPOT_CREATE_LINE_ITEM_OBJECT` * `HUBSPOT_CREATE_LINE_ITEMS` * `HUBSPOT_CREATE_MULTIPLE_TIMELINE_EVENTS_BATCH` * `HUBSPOT_CREATE_NEW_DEAL_OBJECT` * `HUBSPOT_CREATE_NEW_OBJECT_SCHEMA_WITH_CUSTOM_PROPERTIES` * `HUBSPOT_CREATE_OR_UPDATE_DRAFT_VERSION` * `HUBSPOT_CREATE_PIPELINE_FOR_OBJECT_TYPE` * `HUBSPOT_CREATE_PIPELINE_STAGE` * `HUBSPOT_CREATE_PRODUCT` * `HUBSPOT_CREATE_PRODUCT_BATCH` * `HUBSPOT_CREATE_PRODUCT_OBJECT` * `HUBSPOT_CREATE_PRODUCTS` * `HUBSPOT_CREATE_PROPERTY_FOR_SPECIFIED_OBJECT_TYPE` * `HUBSPOT_CREATE_QUOTE_OBJECT` * `HUBSPOT_CREATE_TICKET` * `HUBSPOT_CREATE_TICKET_OBJECT` * `HUBSPOT_CREATE_TICKETS` * `HUBSPOT_CREATE_TIMELINE_EVENT_BASED_ON_TEMPLATE` * `HUBSPOT_CREATE_WORKFLOW` * `HUBSPOT_CUSTOMIZABLE_CONTACTS_PAGE_RETRIEVAL` * `HUBSPOT_DELETE_A_BATCH_OF_CAMPAIGNS` * `HUBSPOT_DELETE_A_MARKETING_EMAIL` * `HUBSPOT_DELETE_CALLING_EXTENSION_SETTINGS` * `HUBSPOT_DELETE_CAMPAIGN` * `HUBSPOT_DELETE_CONTACT_FOR_GDPR_COMPLIANCE` * `HUBSPOT_DELETE_PIPELINE_BY_ID` * `HUBSPOT_DELETE_PIPELINE_STAGE_BY_ID` * `HUBSPOT_DELETE_SCHEMA_BY_OBJECT_TYPE` * `HUBSPOT_DELETE_TIMELINE_EVENT_TEMPLATE` * `HUBSPOT_DELETE_VIDEO_CONFERENCING_APP_SETTINGS` * `HUBSPOT_DELETE_WORKFLOW` * `HUBSPOT_FETCH_CONTACT_DETAILS_BY_ID` # Microsoft Excel Source: https://docs.architect.new/integrations/crm-data/microsoft-excel The Microsoft Excel tool empowers your AI agents to interact directly with your spreadsheets. By integrating Excel, your Architect apps can autonomously read massive datasets, perform complex calculations, generate new workbooks, and update rows in real-time. ## Why Use Microsoft Excel in Architect? Writing VBA macros or complex formulas is tedious. With Architect's vibe coding, you simply describe the data transformations you need in plain English. Your agent handles the underlying logic, turning raw data into actionable insights, formatting cells, and keeping your business trackers up to date autonomously. * **Automated Data Entry:** Have your agent read incoming invoices or emails and automatically append new rows to your central tracking spreadsheet. * **Intelligent Analysis:** Build apps that scan thousands of rows of sales data to spot trends, anomalies, or outstanding payments instantly. * **Dynamic Formatting:** Create agents that not only populate data but also apply conditional formatting, create pivot tables, and generate clean executive dashboards. ## Vibe Coding Examples Try these natural language prompts to build autonomous spreadsheet agents: "Build a finance bot. When I provide a raw CSV of monthly bank transactions, use the Microsoft Excel tool to create a new formatted workbook. Categorize each transaction (e.g., 'Software', 'Travel', 'Meals') and highlight any expense over \$500 in red." "Create an inventory tracker. Every Monday, use the Microsoft Excel tool to read the 'Current Stock' spreadsheet. If any item's quantity is below 10, generate a list of those items and email it to the purchasing manager." "I want a sales research app. I will paste a list of 50 company URLs. For each company, search the web for their headquarters address and employee count, and then use the Microsoft Excel tool to populate this data into the 'Prospects' spreadsheet." Combine data and action! Vibe code an agent that uses Microsoft Excel to find clients whose subscriptions expire this month, and then uses Gmail to automatically send them a renewal reminder. ## Available Actions The Microsoft Excel tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `EXCEL_ADD_CHART` * `EXCEL_ADD_SHAREPOINT_WORKSHEET` * `EXCEL_ADD_TABLE` * `EXCEL_ADD_TABLE_COLUMN` * `EXCEL_ADD_TABLE_ROW` * `EXCEL_ADD_WORKBOOK_PERMISSION` * `EXCEL_ADD_WORKSHEET` * `EXCEL_APPLY_TABLE_FILTER` * `EXCEL_APPLY_TABLE_SORT` * `EXCEL_CLEAR_RANGE` * `EXCEL_CLEAR_TABLE_FILTER` * `EXCEL_CLOSE_SESSION` * `EXCEL_CONVERT_TABLE_TO_RANGE` * `EXCEL_CREATE_WORKBOOK` * `EXCEL_DELETE_TABLE_COLUMN` * `EXCEL_DELETE_TABLE_ROW` * `EXCEL_DELETE_WORKSHEET` * `EXCEL_GET_CHART_AXIS` * `EXCEL_GET_CHART_DATA_LABELS` * `EXCEL_GET_CHART_LEGEND` * `EXCEL_GET_RANGE` * `EXCEL_GET_SESSION` * `EXCEL_GET_SHAREPOINT_RANGE` * `EXCEL_GET_SHAREPOINT_WORKSHEET` * `EXCEL_GET_TABLE_COLUMN` * `EXCEL_GET_WORKBOOK` * `EXCEL_GET_WORKSHEET` * `EXCEL_INSERT_RANGE` * `EXCEL_LIST_CHARTS` * `EXCEL_LIST_CHART_SERIES` * `EXCEL_LIST_COMMENTS` * `EXCEL_LIST_FILES` * `EXCEL_LIST_NAMED_ITEMS` * `EXCEL_LIST_SHAREPOINT_TABLES` * `EXCEL_LIST_SHAREPOINT_WORKSHEETS` * `EXCEL_LIST_TABLE_COLUMNS` * `EXCEL_LIST_TABLE_ROWS` * `EXCEL_LIST_TABLES` * `EXCEL_LIST_WORKBOOK_PERMISSIONS` * `EXCEL_LIST_WORKSHEETS` * `EXCEL_MERGE_CELLS` * `EXCEL_PROTECT_WORKSHEET` * `EXCEL_SORT_RANGE` * `EXCEL_UPDATE_CHART` * `EXCEL_UPDATE_CHART_LEGEND` * `EXCEL_UPDATE_RANGE` * `EXCEL_UPDATE_SHAREPOINT_RANGE` * `EXCEL_UPDATE_TABLE` * `EXCEL_UPDATE_WORKSHEET` # Custom Tools via Lyzr Studio Source: https://docs.architect.new/integrations/custom-tools/custom-tools Need an integration that isn't on the built-in list? Build your own custom tool in Lyzr Studio and plug it into any Architect agent in seconds. ## Why Custom Tools? Architect ships with a growing catalog of pre-built integrations (Gmail, Slack, HubSpot, GitHub, and more). But every team has internal APIs, niche SaaS products, or proprietary services that need to be wired in. **Custom Tools** let you connect any HTTP API or function to your agents without leaving the Lyzr ecosystem. Custom tools are authored in **Lyzr Studio** — the underlying agent platform that powers Architect — and instantly become available to any agent you build in Architect. ## How It Works Every agent you create in Architect can be opened directly in Lyzr Studio for advanced configuration, including custom tool integration. Navigate to your project, open the agent you want to extend, and click the **Edit Agent** panel. In the top-right corner of the Edit Agent panel, click the **Open in Lyzr Studio** button. This launches the same agent in Studio with full access to advanced configuration. Open in Lyzr Studio button highlighted in the Edit Agent panel In Studio, follow the Custom Tools guide to define your tool's endpoint, schema, and authentication. Once saved, the tool is immediately available to your Architect agent. Step-by-step walkthrough for creating, configuring, and attaching custom tools in Lyzr Studio. Return to Architect and prompt your agent normally — it will automatically pick up the new tool and use it when the prompt calls for it. ## What You Can Build Custom tools unlock virtually any external integration: * **Internal APIs:** Connect agents to your company's private microservices, databases, or admin panels. * **Niche SaaS Products:** Wire in vertical tools (legal research platforms, medical records systems, logistics APIs) that aren't in the standard catalog. * **Webhooks & Automation:** Trigger Zapier, Make, or n8n workflows directly from an agent action. * **Custom Logic:** Wrap your own Python or JavaScript functions and expose them as callable tools. Once a custom tool is attached to an agent in Studio, it behaves just like a built-in integration in Architect — no code changes required on the Architect side. ## Need Help? For detailed instructions on authoring custom tools — including authentication, parameter schemas, response handling, and testing — refer to the official Lyzr Studio documentation: Complete reference for building and managing custom tools in Lyzr Studio. # Connecting MCP Servers Source: https://docs.architect.new/integrations/custom-tools/mcp-servers Bring any Model Context Protocol (MCP) server into your Architect app — connect it once and your agents can use its tools. ## What is an MCP Server? **MCP (Model Context Protocol)** is an open standard for connecting AI agents to external tools and data sources. If a capability you need isn't in Architect's [built-in integrations](/integrations/communication/gmail) — a niche SaaS product, an internal API exposed over MCP, or a public MCP server like DeepWiki — you can connect it as an MCP server and let your agents call its actions. **MCP servers are tied to your Lyzr account, not a single app.** Once you connect a server, it's available to *every* app you build under the same account — connect it once, reuse it everywhere. They're authenticated under your account, so your agents can use them without any extra keys. There are two ways to connect an MCP server to your Architect app. ## Method 1 — Connect in Lyzr Studio first, then just ask (recommended) If you already know which MCP server you need, connect it in **Lyzr Studio** before you start building. Architect automatically sees all your connected MCP servers, so you just reference it in your prompt. In the Architect sidebar, click **Agent Studio** to open Lyzr Studio. Agent Studio link highlighted in the Architect sidebar In Studio's left sidebar, open **Connections** and choose **Tools**. Connections menu expanded to Tools in Lyzr Studio Switch to the **MCP** tab. You can either pick a ready-made server from **Available MCP Servers** (DeepWiki, Stripe, Supabase, and more), or click **+ New → MCP Server** to connect your own. MCP tab showing connected servers, available servers, and the + New → MCP Server option Give it a **name** and optional **description**, paste the **Server URL**, and pick an **Auth Type** — **No Auth**, **API Key**, or **OAuth**. Save it, and the server is now connected under your account. Add MCP Server dialog: name, description, server URL, and auth type Back in Architect, on the homepage, describe your app **and name the MCP server** you want it to use. Being specific helps Architect pick the right one. For example: > *I've connected Parallel Search MCP server in lyzr studio. Build an agent that uses it to search the web and show the results in a dashboard.* Architect homepage with a prompt naming the connected Parallel Search MCP server While building, Architect reads your live list of connected MCP servers, finds the one you named, and attaches it to the agent it creates — wiring up the server's available actions. No manual configuration needed. For this to work, the server must be **connected and reporting its actions** in Studio. If a server shows as connected but lists no actions, Studio couldn't fetch its action list — re-check the server and try again. Architect will never invent or fake a tool it can't see. ## Method 2 — Add an MCP server mid-build (to an app you've already built) Already built your app and want to plug in a new MCP server in a later iteration? You can connect one **directly from Architect's build chat** — no need to switch over to Studio. In your app's **Build** view, click the **“+”** button in the message composer and choose **Add MCP server**. (You can also type **`@mcp:`** to open the MCP menu, which lists your already-connected servers and offers to add a new one.) The + menu in the Architect build chat showing 'Add MCP server' In the **Add MCP server** dialog, give it a **name**, paste the **Server URL**, and pick an **Authentication** type — then click **Connect**. | Auth type | Use it when | | ----------- | ------------------------------------------------ | | **No auth** | Public server — no credentials (e.g. DeepWiki) | | **API key** | The server needs a key, sent as a request header | | **OAuth** | Authorize in a popup window | The server is saved to your account (just like connecting it in Studio) and becomes available to your agents. Add MCP server dialog inside Architect: name, server URL, and authentication In the same chat, ask Architect to wire the newly connected server into your app. It picks it up from your live server list, attaches it to the agent, and rebuilds the affected part. ## What if I ask for an MCP I haven't connected? Architect won't fake the connection. If you prompt it to use a server that isn't in your account (say, *"connect with DeepWiki MCP"* when DeepWiki isn't connected yet), it will tell you — in plain language — to add that server first using the **“+” / Add MCP server** button, naming the capability it needs. Once you add it (a quick form: name, URL, auth), continue the chat and Architect wires it in. ## MCP servers vs. built-in tools The same capability can sometimes exist both as a **built-in Architect integration** and as **your own MCP server** (for example, Linear). They're different tools — Architect uses your MCP server only when you explicitly ask for it; otherwise it uses the pre-built integration. When in doubt, name the MCP server in your prompt so there's no ambiguity. Prefer connecting a full custom tool with a defined schema instead? See [Custom Tools via Lyzr Studio](/integrations/custom-tools/custom-tools). ## Troubleshooting Is your MCP-powered app not working — the agent doesn't respond, or the data from the MCP never shows up? Work through these checks **in order**. The goal is to figure out whether it's an **MCP/agent problem** (the data isn't being fetched at all) or a **UI problem** (the data *is* fetched but Architect isn't displaying it). In Lyzr Studio, go to **Connections → Tools → MCP** tab and find your server under **My MCP Servers**. A **green dot** means it's connected. If it's missing or not showing green, re-add / reconnect it first (see [Method 1](#method-1-connect-in-lyzr-studio-first-then-just-ask-recommended)). My MCP Servers in Lyzr Studio, each with a green connected indicator In Architect, open the **Agents** tab, click your agent to open the **Edit Agent** panel, and click **Open in Lyzr Studio**. Edit Agent panel in Architect with the Open in Lyzr Studio button In Studio's **Manage Agent** page, check the **Tool Configuration** section — your MCP server and its actions (for example `ask_question`, `read_wiki_contents`, `read_wiki_structure`) should be listed. If they're missing, the agent isn't wired to the MCP. Tool Configuration in Lyzr Studio showing the MCP server's actions attached to the agent On the same Manage Agent page, use the **Test Agent Inference → Chat** panel on the right. Ask it something that needs the MCP — for example: *"Can you fetch some information from the MCP connected."* Test Agent Inference chat in Lyzr Studio with a prompt asking the agent to fetch data from the connected MCP ### Reading the result **The agent fetches the data in Studio →** the agent and its MCP connection are working correctly. The problem is almost certainly in your **app's UI** — Architect built the interface, but it isn't rendering the response. Go back to Architect and prompt it, for example: > *"The agent can fetch the response from the MCP fine, but I can't see it in the UI. Can you fix that?"* **The agent can't fetch the data in Studio →** this is most likely an **MCP error or MCP connection error**, not a UI issue. Re-check the MCP server (Step 1): its URL, its auth type, and that its actions are listed. Reconnect it if needed and re-test in Studio *before* going back to Architect. # Arxiv Source: https://docs.architect.new/integrations/dev-research/arxiv The Arxiv tool gives your AI agents direct access to the world's largest repository of scientific papers and preprints. Whether you are building an app for academic research, technical scouting, or literature reviews, this tool allows your agent to query, retrieve, and analyze cutting-edge research instantly. ## Why Use Arxiv in Architect? Instead of manually searching repositories, downloading PDFs, and reading through dense abstracts, you can vibe code an expert research assistant. Just tell Architect what field or topic you want to explore, and the AI will use the Arxiv tool to hunt down the exact papers you need. * **Automated Literature Reviews:** Have your agent instantly compile and summarize the latest research on highly specific technical topics. * **Trend Spotting:** Build apps that monitor new submissions in AI, physics, or quantitative finance to keep your team ahead of the curve. * **Complex Querying:** Let the AI figure out the best search parameters to find relevant papers instead of wrestling with boolean search strings yourself. ## Vibe Coding Examples Try these natural language prompts in Architect to build Arxiv-powered research tools: "Build a research agent. I will give it a technical topic, like 'Large Language Model Hallucinations'. It should use the Arxiv tool to fetch the 5 most relevant and recent papers, and generate a 1-paragraph summary for each." "Create an app that tracks quantum computing advancements. It needs to search Arxiv for any papers published this week containing 'Quantum Error Correction', and draft a readable newsletter highlighting the key breakthroughs." "I want an educational app. When a user asks about a complex math concept, use the Arxiv tool to find a foundational paper on that topic, and then break down the abstract into simple terms that a high schooler could understand." Combine the Arxiv tool with the Notion or Google Docs tool in your prompt so the agent automatically saves its research summaries into your workspace! ## Available Actions The Arxiv tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `ARXIVSEARCH_PAPERS` * `ARXIVGET_PAPER_METADATA` * `ARXIVDOWNLOAD_PAPER` * `ARXIVGET_CATEGORIES` * `ARXIV_GET_DAILY_UPDATES` # GitHub Source: https://docs.architect.new/integrations/dev-research/github The GitHub tool transforms your AI agents into autonomous software developers and repository managers. By connecting GitHub to Architect, your apps can dynamically read code, analyze commits, manage pull requests, and triage issues across your repositories. ## Why Use GitHub in Architect? Vibe coding isn't just for building end-user apps; it's perfect for building your own internal developer tooling. Instead of relying on rigid CI/CD scripts or manual code reviews, you can simply tell your agent how you want your repository managed. The GitHub tool empowers the AI to act as a tireless open-source maintainer or an extra pair of eyes on your team's code. * **Automated Code Reviews:** Build agents that automatically pull the latest PRs, analyze the code for security flaws or anti-patterns, and leave actionable comments. * **Intelligent Issue Triaging:** Stop manually tagging bugs. Have your agent read incoming issues, reproduce steps conceptually, assign the right labels (e.g., 'bug', 'enhancement'), and ping the relevant developer. * **Documentation Generation:** Instruct your agent to read through a specific folder in your repo and automatically draft comprehensive READMEs or technical docs. ## Vibe Coding Examples Try these natural language prompts in Architect to build powerful GitHub automations: "Build a code review assistant. Use the GitHub tool to fetch the latest open Pull Request in my repository. Analyze the diff for potential performance bottlenecks and security issues, and then post a summary comment on the PR." "Create an app that manages my open-source repo. Whenever a new issue is created, read its contents. If it mentions 'UI' or 'CSS', use the GitHub tool to add a 'frontend' label and assign it to the design team." "I need a release note generator. Use the GitHub tool to fetch all the commit messages from the past week on the main branch. Group them logically into 'Features', 'Fixes', and 'Chores', and format them into a clean markdown changelog." Vibe code an ultimate dev-ops agent by combining the GitHub tool with Slack or Microsoft Teams. Have the agent review a PR and immediately send a direct message to the author with a summary of the feedback! ## Available Actions The GitHub tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `GITHUB_ACCEPT_A_REPOSITORY_INVITATION` * `GITHUB_ACTIVITY_LIST_REPO_S_STARRED_BY_AUTHENTICATED_USER` * `GITHUB_ACTIVITY_LIST_STARGAZERS_FOR_REPO` * `GITHUB_ACTIVITY_STAR_REPO_FOR_AUTHENTICATED_USER` * `GITHUB_ADD_AN_EMAIL_ADDRESS_FOR_THE_AUTHENTICATED_USER` * `GITHUB_ADD_APP_ACCESS_RESTRICTIONS` * `GITHUB_ADD_A_REPOSITORY_COLLABORATOR` * `GITHUB_ADD_A_REPOSITORY_TO_AN_APP_INSTALLATION` * `GITHUB_ADD_A_SELECTED_REPOSITORY_TO_A_USER_SECRET` * `GITHUB_ADD_ASSIGNEES_TO_AN_ISSUE` * `GITHUB_ADD_LABELS_TO_AN_ISSUE` * `GITHUB_ADD_ORG_RUNNER_LABELS` * `GITHUB_ADD_OR_UPDATE_TEAM_MEMBERSHIP_FOR_A_USER` * `GITHUB_ADD_OR_UPDATE_TEAM_PROJECT_PERMISSIONS` * `GITHUB_ADD_OR_UPDATE_TEAM_REPOSITORY_PERMISSIONS` * `GITHUB_ADD_PROJECT_COLLABORATOR` * `GITHUB_ADD_REPO_TO_ORG_SECRET_WITH_SELECTED_ACCESS` * `GITHUB_ADD_REPO_TO_ORG_SECRET_WITH_SELECTED_VISIBILITY` * `GITHUB_ADD_RUNNER_LABELS` * `GITHUB_ADD_SELECTED_REPOSITORY_TO_AN_ORGANIZATION_SECRET` * `GITHUB_ADD_SELECTED_REPOSITORY_TO_AN_ORGANIZATION_VARIABLE` * `GITHUB_ADD_SOCIAL_ACCOUNTS_FOR_THE_AUTHENTICATED_USER` * `GITHUB_ADD_STATUS_CHECK_CONTEXTS` * `GITHUB_ADD_TEAM_ACCESS_RESTRICTIONS` * `GITHUB_ADD_USER_ACCESS_RESTRICTIONS` * `GITHUB_ADD_USERS_TO_CODESPACES_ACCESS_FOR_AN_ORGANIZATION` * `GITHUB_APPROVE_A_WORKFLOW_RUN_FOR_A_FORK_PULL_REQUEST` * `GITHUB_ASSIGN_AN_ORGANIZATION_ROLE_TO_A_TEAM` * `GITHUB_ASSIGN_AN_ORGANIZATION_ROLE_TO_A_USER` * `GITHUB_AUTH_USER_DOCKER_CONFLICT_PACKAGES_LIST` * `GITHUB_BLOCK_A_USER` * `GITHUB_BLOCK_A_USER_FROM_AN_ORGANIZATION` * `GITHUB_CANCEL_A_GITHUB_PAGES_DEPLOYMENT` * `GITHUB_CANCEL_A_WORKFLOW_RUN` * `GITHUB_CHECK_A_TOKEN` * `GITHUB_CHECK_IF_A_GIST_IS_STARRED` * `GITHUB_CHECK_IF_A_PERSON_IS_FOLLOWED_BY_THE_AUTHENTICATED_USER` * `GITHUB_CHECK_IF_A_PULL_REQUEST_HAS_BEEN_MERGED` * `GITHUB_CHECK_IF_A_REPOSITORY_IS_STARRED_BY_THE_AUTHENTICATED_USER` * `GITHUB_CHECK_IF_A_USER_CAN_BE_ASSIGNED` * `GITHUB_CHECK_IF_A_USER_CAN_BE_ASSIGNED_TO_A_ISSUE` * `GITHUB_CHECK_IF_A_USER_FOLLOWS_ANOTHER_USER` * `GITHUB_CHECK_IF_A_USER_IS_A_REPOSITORY_COLLABORATOR` * `GITHUB_CHECK_IF_A_USER_IS_BLOCKED_BY_AN_ORGANIZATION` * `GITHUB_CHECK_IF_A_USER_IS_BLOCKED_BY_THE_AUTHENTICATED_USER` * `GITHUB_CHECK_PRIVATE_VULNERABILITY_REPORTING_STATUS` * `GITHUB_CHECK_TEAM_PERMISSIONS_FOR_A_PROJECT` * `GITHUB_CHECK_TEAM_PERMISSIONS_FOR_A_REPOSITORY` * `GITHUB_CLEAR_REPOSITORY_CACHE_BY_KEY` * `GITHUB_CLEAR_SELF_HOSTED_RUNNER_ORG_LABELS` * `GITHUB_COMPARE_TWO_COMMITS` * `GITHUB_CONFIGURE_JITRUNNER_FOR_ORG` * `GITHUB_CONFIGURE_OIDCSUBJECT_CLAIM_TEMPLATE` * `GITHUB_CONVERT_AN_ORGANIZATION_MEMBER_TO_OUTSIDE_COLLABORATOR` * `GITHUB_CREATE_A_BLOB` * `GITHUB_CREATE_A_CHECK_RUN` * `GITHUB_CREATE_A_CHECK_SUITE` * `GITHUB_CREATE_A_CODESPACE_FOR_THE_AUTHENTICATED_USER` * `GITHUB_CREATE_A_CODESPACE_FROM_A_PULL_REQUEST` * `GITHUB_CREATE_A_CODESPACE_IN_A_REPOSITORY` * `GITHUB_CREATE_A_COMMIT` * `GITHUB_CREATE_A_COMMIT_COMMENT` * `GITHUB_CREATE_A_COMMIT_STATUS` * `GITHUB_CREATE_A_CUSTOM_ORGANIZATION_ROLE` * `GITHUB_CREATE_A_DEPLOY_KEY` * `GITHUB_CREATE_A_DEPLOYMENT` * `GITHUB_CREATE_A_DEPLOYMENT_BRANCH_POLICY` * `GITHUB_CREATE_A_DEPLOYMENT_STATUS` * `GITHUB_CREATE_A_DISCUSSION` * `GITHUB_CREATE_A_DISCUSSION_COMMENT` * `GITHUB_CREATE_A_FORK` * `GITHUB_CREATE_A_GIST` * `GITHUB_CREATE_A_GIST_COMMENT` * `GITHUB_CREATE_A_GITHUB_APP_FROM_A_MANIFEST` * `GITHUB_CREATE_A_GITHUB_PAGES_DEPLOYMENT` * `GITHUB_CREATE_A_GITHUB_PAGES_SITE` * `GITHUB_CREATE_A_LABEL` * `GITHUB_CREATE_A_MILESTONE` * `GITHUB_CREATE_AN_AUTOLINK_REFERENCE_FOR_A_REPOSITORY` * `GITHUB_CREATE_AN_ENVIRONMENT_VARIABLE` * `GITHUB_CREATE_AN_ISSUE` * `GITHUB_CREATE_AN_ISSUE_COMMENT` * `GITHUB_CREATE_AN_ORGANIZATION_PROJECT` * `GITHUB_CREATE_AN_ORGANIZATION_REPOSITORY` * `GITHUB_CREATE_AN_ORGANIZATION_VARIABLE` * `GITHUB_CREATE_AN_ORGANIZATION_WEBHOOK` * `GITHUB_CREATE_A_PROJECT_CARD` * `GITHUB_CREATE_A_PROJECT_COLUMN` * `GITHUB_CREATE_A_PULL_REQUEST` * `GITHUB_CREATE_A_REFERENCE` * `GITHUB_CREATE_A_REGISTRATION_TOKEN_FOR_AN_ORGANIZATION` * `GITHUB_CREATE_A_REGISTRATION_TOKEN_FOR_A_REPOSITORY` * `GITHUB_CREATE_A_RELEASE` * `GITHUB_CREATE_A_REMOVE_TOKEN_FOR_AN_ORGANIZATION` * `GITHUB_CREATE_A_REMOVE_TOKEN_FOR_A_REPOSITORY` * `GITHUB_CREATE_A_REPLY_FOR_A_REVIEW_COMMENT` * `GITHUB_CREATE_A_REPOSITORY_DISPATCH_EVENT` * `GITHUB_CREATE_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER` * `GITHUB_CREATE_A_REPOSITORY_FROM_AN_UNPUBLISHED_CODESPACE` * `GITHUB_CREATE_A_REPOSITORY_PROJECT` # Jira Source: https://docs.architect.new/integrations/dev-research/jira The Jira tool connects your AI agents deeply into your agile development environment. By integrating Jira into Architect, your apps can autonomously create epics, transition issues across sprints, log bugs, and compile release notes. ## Why Use Jira in Architect? Keeping Jira updated is a notorious time-sink for engineers and product managers. With Architect's vibe coding, you can describe how engineering tasks should be tracked, and your agent will enforce your agile methodology. Turn raw meeting notes or Slack complaints into perfectly formatted Jira tickets instantly. * **Automated Bug Logging:** Build agents that capture errors from your communication channels, extract the steps to reproduce, and file a Jira ticket with the correct priority and component labels. * **Sprint Summaries:** Have an agent fetch all issues in the active sprint, summarize the blocked or delayed items, and generate a standup report. * **Epic Breakdown:** Create an autonomous Product Manager that takes a one-paragraph feature idea and breaks it down into a parent Epic with five distinct user-story child tickets in Jira. ## Vibe Coding Examples Try these natural language prompts to build engineering productivity agents: "Build a product management app. When I upload a Product Requirements Document (PRD), use the Jira tool to create a new Epic, and automatically generate and link the necessary user stories and sub-tasks required to build the feature." "Create an IT support bot. When a team member reports a hardware issue in Slack, use the Jira tool to create a ticket in the IT Service Desk project. Set the issue type to 'Hardware Request' and assign it to the IT admin." "I want an agile coach agent. At the end of our two-week sprint, use the Jira tool to fetch all tickets that moved to 'Done'. Generate a markdown report highlighting our completed story points and any bugs that carried over." Combine Jira with GitHub! Vibe code an agent that reads closed Pull Requests in GitHub and automatically transitions the associated Jira tickets from 'In Review' to 'Done'. ## Available Actions The Jira tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `JIRA_ADD_ATTACHMENT` * `JIRA_ADD_COMMENT` * `JIRA_ADD_WATCHER_TO_ISSUE` * `JIRA_ASSIGN_ISSUE` * `JIRA_BULK_CREATE_ISSUE` * `JIRA_CREATE_ISSUE` * `JIRA_CREATE_ISSUE_LINK` * `JIRA_CREATE_PROJECT` * `JIRA_CREATE_SPRINT` * `JIRA_CREATE_VERSION` * `JIRA_DELETE_COMMENT` * `JIRA_DELETE_ISSUE` * `JIRA_DELETE_VERSION` * `JIRA_DELETE_WORKLOG` * `JIRA_EDIT_ISSUE` * `JIRA_FIND_USERS` * `JIRA_GET_ALL_ISSUE_TYPE_SCHEMES` * `JIRA_GET_ALL_PROJECTS` * `JIRA_GET_ALL_STATUSES` * `JIRA_GET_ALL_USERS` * `JIRA_GET_COMMENT` * `JIRA_GET_CURRENT_USER` * `JIRA_GET_ISSUE` * `JIRA_GET_ISSUE_LINK_TYPES` * `JIRA_GET_ISSUE_PROPERTY` * `JIRA_GET_ISSUE_RESOLUTIONS` * `JIRA_GET_ISSUE_TYPES` * `JIRA_GET_ISSUE_TYPE_SCHEME` * `JIRA_GET_ISSUE_WATCHERS` * `JIRA_GET_ISSUE_WORKLOGS` * `JIRA_GET_PROJECT_VERSIONS` * `JIRA_GET_REMOTE_ISSUE_LINKS` * `JIRA_GET_TRANSITIONS` * `JIRA_GET_VOTES` * `JIRA_GET_WORKLOG` * `JIRA_LIST_BOARDS` * `JIRA_LIST_ISSUE_COMMENTS` * `JIRA_LIST_SPRINTS` * `JIRA_MOVE_ISSUE_TO_SPRINT` * `JIRA_REMOVE_WATCHER_FROM_ISSUE` * `JIRA_SEARCH_FOR_ISSUES_USING_JQL_GET` * `JIRA_SEARCH_FOR_ISSUES_USING_JQL_POST` * `JIRA_SEARCH_ISSUES` * `JIRA_SEND_NOTIFICATION_FOR_ISSUE` * `JIRA_TRANSITION_ISSUE` * `JIRA_UPDATE_COMMENT` # Linear Source: https://docs.architect.new/integrations/dev-research/linear The Linear tool connects your AI agents directly to your software engineering workflows. By integrating Linear, your Architect apps can autonomously create bug tickets, track feature requests, assign issues to developers, and manage project cycles. ## Why Use Linear in Architect? Managing engineering tickets shouldn't be a bottleneck. With vibe coding, you can bridge the gap between user feedback and developer action instantly. Simply describe how you want bugs or feature requests handled, and your agent will act as an autonomous product manager, perfectly formatting and triaging tickets in Linear. * **Automated Bug Triaging:** Have an agent read customer support messages, extract steps to reproduce the error, and file a perfectly formatted Linear ticket. * **Smart Routing:** Build apps that automatically assign Linear issues to specific teams or developers based on keywords in the task description. * **Sprint Summaries:** Create tools that fetch all completed Linear tickets for the current cycle and generate comprehensive release notes. ## Vibe Coding Examples Try these natural language prompts to build engineering productivity agents: "Build an IT support agent. When a user pastes a bug report, use the Linear tool to create a new issue. Set the priority to 'High', format the description to include 'Expected Behavior' and 'Actual Behavior', and tag it with 'Bug'." "Create a product feedback app. Analyze user reviews. If a review mentions a missing feature, use the Linear tool to check if a similar issue already exists. If not, create a new feature request ticket in the 'Product Backlog' team." "I want a developer standup assistant. Use the Linear tool to fetch all issues assigned to me that are marked 'In Progress'. Generate a brief summary of what I am currently working on to share in my morning meeting." Vibe code an end-to-end dev flow! Have the agent read a PR using the GitHub tool and automatically update the associated issue status to "Done" using the Linear tool! ## Available Actions The Linear tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `LINEAR_CREATE_LINEAR_ATTACHMENT` * `LINEAR_CREATE_LINEAR_COMMENT` * `LINEAR_CREATE_LINEAR_ISSUE` * `LINEAR_CREATE_LINEAR_ISSUE_DETAILS` * `LINEAR_CREATE_LINEAR_LABEL` * `LINEAR_DELETE_LINEAR_ISSUE` * `LINEAR_GET_ALL_LINEAR_TEAMS` * `LINEAR_GET_ATTACHMENTS` * `LINEAR_GET_CURRENT_USER` * `LINEAR_GET_CYCLES_BY_TEAM_ID` * `LINEAR_GET_LINEAR_ISSUE` * `LINEAR_LIST_LINEAR_CYCLES` * `LINEAR_LIST_LINEAR_ISSUES` * `LINEAR_LIST_LINEAR_LABELS` * `LINEAR_LIST_LINEAR_PROJECTS` * `LINEAR_LIST_LINEAR_STATES` * `LINEAR_LIST_LINEAR_TEAMS` * `LINEAR_LIST_LINEAR_USERS` * `LINEAR_REMOVE_ISSUE_LABEL` * `LINEAR_RUN_QUERY_OR_MUTATION` * `LINEAR_UPDATE_ISSUE` # Asana Source: https://docs.architect.new/integrations/workspace/asana The Asana tool allows your AI agents to seamlessly interact with your project management workspace. By integrating Asana, your apps can dynamically create tasks, assign team members, update statuses, and pull project contexts directly into your automated workflows. ## Why Use Asana in Architect? Project management shouldn't mean endless data entry. With Architect's vibe coding approach, you can tell your AI exactly how your team works, and it will handle the Asana administration for you. Turn unstructured data—like meeting notes, emails, or chat messages—into perfectly organized tasks without writing any code. * **Automated Task Creation:** Turn a wall of text into actionable, assigned tickets in your Asana board instantly. * **Smart Triage:** Build agents that read incoming requests, categorize them, and route them to the correct Asana project based on the content. * **Project Auditing:** Have an agent review your Asana workspace to identify bottlenecks or overdue tasks and summarize them for you. ## Vibe Coding Examples Use these natural language prompts in Architect to build autonomous project management agents: "Build an AI project manager. Whenever I paste a transcript from a Zoom meeting, analyze it for action items. Then, use the Asana tool to create a task for each action item, add a brief description, and assign it to the mentioned team member." "Create an app that processes customer feedback. If the feedback contains a bug report, use the Asana tool to create a high-priority task in the 'Engineering' project. If it's a feature request, put it in the 'Product Backlog' project." "I want an assistant for my daily standups. Use Asana to fetch all tasks completed in the last 24 hours and all tasks currently marked as 'In Progress'. Generate a bulleted summary of our team's velocity for the day." Vibe code an integration between Asana and Slack! Prompt your agent to automatically post a summary of new Asana tasks into your team's Slack channel so everyone stays aligned. ## Available Actions The Asana tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `ASANA_ADD_FOLLOWERS_TO_TASK` * `ASANA_ADD_SUPPORTING_RELATIONSHIP` * `ASANA_ADD_TASK_TO_SECTION` * `ASANA_CREATE_ALLOCATION` * `ASANA_CREATE_A_PROJECT` * `ASANA_CREATE_A_TAG_IN_A_WORKSPACE` * `ASANA_CREATE_A_TASK` * `ASANA_CREATE_ATTACHMENT_FOR_TASK` * `ASANA_CREATE_CUSTOM_FIELD` * `ASANA_CREATE_ENUM_OPTION_FOR_CUSTOM_FIELD` * `ASANA_CREATE_PROJECT_STATUS_UPDATE` * `ASANA_CREATE_SECTION_IN_PROJECT` * `ASANA_CREATE_SUBTASK` * `ASANA_CREATE_TASK_COMMENT` * `ASANA_CREATE_TEAM` * `ASANA_DELETE_ALLOCATION` * `ASANA_DELETE_ATTACHMENT` * `ASANA_DELETE_CUSTOM_FIELD` * `ASANA_DELETE_PROJECT` * `ASANA_DELETE_TAG` * `ASANA_DELETE_TASK` * `ASANA_DUPLICATE_PROJECT` * `ASANA_DUPLICATE_TASK` * `ASANA_GET_ALLOCATION` * `ASANA_GET_ALLOCATIONS` * `ASANA_GET_A_PROJECT` * `ASANA_GET_A_TASK` * `ASANA_GET_ATTACHMENT` * `ASANA_GET_AUDIT_LOG_EVENTS` * `ASANA_GET_A_USER_TASK_LIST` * `ASANA_GET_CURRENT_USER` * `ASANA_GET_CUSTOM_FIELD` * `ASANA_GET_CUSTOM_FIELDS_FOR_WORKSPACE` * `ASANA_GET_EVENTS` * `ASANA_GET_GOAL` * `ASANA_GET_GOAL_RELATIONSHIPS` * `ASANA_GET_GOALS` * `ASANA_GET_MEMBERSHIPS` * `ASANA_GET_MULTIPLE_PROJECTS` * `ASANA_GET_MULTIPLE_TASKS` * `ASANA_GET_MULTIPLE_USERS` * `ASANA_GET_MULTIPLE_WORKSPACES` * `ASANA_GET_PORTFOLIO` * `ASANA_GET_PORTFOLIO_ITEMS` * `ASANA_GET_PORTFOLIO_MEMBERSHIPS` * `ASANA_GET_PORTFOLIOS` * `ASANA_GET_PROJECT_BRIEF` * `ASANA_GET_PROJECT_MEMBERSHIPS` * `ASANA_GET_PROJECTS_FOR_TEAM` * `ASANA_GET_PROJECT_STATUS` * `ASANA_GET_PROJECT_STATUS_UPDATES` * `ASANA_GET_PROJECT_TEMPLATES` * `ASANA_GET_SECTION` * `ASANA_GET_SECTIONS_IN_PROJECT` * `ASANA_GET_STATUS_UPDATES` * `ASANA_GET_STORIES_FOR_TASK` * `ASANA_GET_STORY` * `ASANA_GET_TAG` * `ASANA_GET_TAGS` * `ASANA_GET_TASK_ATTACHMENTS` * `ASANA_GET_TASKS_FROM_A_PROJECT` * `ASANA_GET_TASK_SUBTASKS` * `ASANA_GET_TASK_TEMPLATES` * `ASANA_GET_TEAM` * `ASANA_GET_TEAM_MEMBERSHIPS` * `ASANA_GET_TEAMS_IN_WORKSPACE` * `ASANA_GET_TIME_PERIODS` * `ASANA_GET_TYPEAHEAD_OBJECTS` * `ASANA_GET_USER` * `ASANA_GET_USERS_FOR_TEAM` * `ASANA_GET_USERS_FOR_WORKSPACE` * `ASANA_GET_WORKSPACE` * `ASANA_GET_WORKSPACE_MEMBERSHIPS` * `ASANA_GET_WORKSPACE_PROJECTS` * `ASANA_INSERT_ENUM_OPTION_FOR_CUSTOM_FIELD` * `ASANA_REMOVE_FOLLOWER_FROM_TASK` * `ASANA_SUBMIT_PARALLEL_REQUESTS` * `ASANA_UPDATE_ALLOCATION` * `ASANA_UPDATE_A_TASK` * `ASANA_UPDATE_CUSTOM_FIELD` * `ASANA_UPDATE_ENUM_OPTION` * `ASANA_UPDATE_PROJECT` * `ASANA_UPDATE_TAG` * `ASANA_UPDATE_TEAM` # Confluence Source: https://docs.architect.new/integrations/workspace/confluence The Confluence tool connects your AI agents directly to your enterprise wiki. By integrating Confluence into Architect, your apps can autonomously draft technical documentation, update project spaces, and surface internal company knowledge. ## Why Use Confluence in Architect? Technical documentation is often out of date because it requires manual effort to maintain. Through vibe coding, you can describe documentation standards, and your agent will enforce them. Whether drafting release notes, updating architecture docs, or answering developer queries, the Confluence tool keeps your wiki alive. * **Auto-Generated Docs:** Instruct your agent to read code changes or project briefs and automatically draft structured documentation pages in Confluence. * **Meeting Archival:** Build apps that capture engineering standups and automatically publish the notes to the correct team space. * **Intelligent Q\&A:** Create internal helpdesk bots that query your entire Confluence workspace to provide instant, accurate answers to complex technical questions. ## Vibe Coding Examples Try these natural language prompts to build enterprise documentation agents: "Build a DevOps agent. When a new version is deployed, fetch the commit history, summarize the new features, and use the Confluence tool to publish a 'Release Notes' page in the Engineering space." "Create an HR assistant. When a new employee is hired, use the Confluence tool to generate a personalized 30-day onboarding page containing relevant links and team contacts." "I want an internal support bot. When a developer asks how to deploy to staging, use the Confluence tool to search the wiki, find the deployment guide, and extract the step-by-step instructions." Combine Confluence with Jira! Prompt your agent to automatically generate a Confluence documentation page whenever a Jira Epic is marked as 'Done'. ## Available Actions The Confluence tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `CONFLUENCE_ADD_CONTENT_LABEL` * `CONFLUENCE_CONFLUENCE_GET_SPACE_BY_ID` * `CONFLUENCE_CREATE_BLOGPOST` * `CONFLUENCE_CREATE_BLOGPOST_PROPERTY` * `CONFLUENCE_CREATE_CONTENT_PROPERTY_FOR_WHITEBOARD` * `CONFLUENCE_CREATE_PAGE` * `CONFLUENCE_CREATE_PAGE_PROPERTY` * `CONFLUENCE_CREATE_PRIVATE_SPACE` * `CONFLUENCE_CREATE_SPACE` * `CONFLUENCE_CREATE_SPACE_PROPERTY` * `CONFLUENCE_CREATE_WHITEBOARD` * `CONFLUENCE_DELETE_BLOGPOST_PROPERTY` * `CONFLUENCE_DELETE_CONTENT_PROPERTY_FOR_PAGE_BY_ID` * `CONFLUENCE_DELETE_CONTENT_PROPERTY_FOR_WHITEBOARD_BY_ID` * `CONFLUENCE_DELETE_PAGE` * `CONFLUENCE_DELETE_SPACE` * `CONFLUENCE_DELETE_SPACE_PROPERTY` * `CONFLUENCE_GET_ATTACHMENT_LABELS` * `CONFLUENCE_GET_ATTACHMENTS` * `CONFLUENCE_GET_AUDIT_LOGS` * `CONFLUENCE_GET_BLOGPOST_BY_ID` * `CONFLUENCE_GET_BLOGPOST_LABELS` * `CONFLUENCE_GET_BLOGPOST_LIKE_COUNT` * `CONFLUENCE_GET_BLOGPOST_OPERATIONS` * `CONFLUENCE_GET_BLOGPOSTS` * `CONFLUENCE_GET_BLOG_POSTS` * `CONFLUENCE_GET_BLOG_POSTS_FOR_LABEL` * `CONFLUENCE_GET_BLOGPOST_VERSION_DETAILS` * `CONFLUENCE_GET_BLOGPOST_VERSIONS` * `CONFLUENCE_GET_CHILD_PAGES` * `CONFLUENCE_GET_CONTENT_PROPERTIES_FOR_BLOG_POST` * `CONFLUENCE_GET_CONTENT_PROPERTIES_FOR_PAGE` * `CONFLUENCE_GET_CONTENT_RESTRICTIONS` * `CONFLUENCE_GET_CURRENT_USER` * `CONFLUENCE_GET_INLINE_COMMENTS_FOR_BLOG_POST` * `CONFLUENCE_GET_LABELS` * `CONFLUENCE_GET_LABELS_FOR_PAGE` * `CONFLUENCE_GET_LABELS_FOR_SPACE` * `CONFLUENCE_GET_LABELS_FOR_SPACE_CONTENT` * `CONFLUENCE_GET_PAGE_ANCESTORS` * `CONFLUENCE_GET_PAGE_BY_ID` * `CONFLUENCE_GET_PAGE_LIKE_COUNT` * `CONFLUENCE_GET_PAGES` * `CONFLUENCE_GET_PAGE_VERSIONS` * `CONFLUENCE_GET_SPACE_BY_ID` * `CONFLUENCE_GET_SPACE_CONTENTS` * `CONFLUENCE_GET_SPACE_PROPERTIES` * `CONFLUENCE_GET_SPACES` * `CONFLUENCE_GET_USER_ANONYMOUS` * `CONFLUENCE_SEARCH_CONTENT` * `CONFLUENCE_SEARCH_USERS` * `CONFLUENCE_UPDATE_BLOGPOST` * `CONFLUENCE_UPDATE_BLOGPOST_PROPERTY` * `CONFLUENCE_UPDATE_CONTENT_PROPERTY_FOR_PAGE_BY_ID` * `CONFLUENCE_UPDATE_CONTENT_PROPERTY_FOR_WHITEBOARD_BY_ID` * `CONFLUENCE_UPDATE_PAGE` * `CONFLUENCE_UPDATE_SPACE_PROPERTY` # Dropbox Source: https://docs.architect.new/integrations/workspace/dropbox The Dropbox tool gives your AI agents a secure, direct line to your file storage. By connecting Dropbox to Architect, your agents can autonomously search for documents, read file contents, organize folders, and save newly generated files straight to your cloud storage. ## Why Use Dropbox in Architect? Managing files is tedious. With Architect’s vibe coding approach, you don’t have to manually download PDFs, read them, and upload summaries back to the cloud. You simply describe the file operations you want to happen, and your agent uses the Dropbox tool to execute them flawlessly in the background. * **Automated Document Processing:** Have your agent read through hundreds of invoices or contracts stored in a folder and extract the key data automatically. * **Intelligent Organization:** Build apps that scan messy upload folders and automatically sort files into the correct client directories based on their content. * **Seamless Report Generation:** Create research agents that compile data and save beautifully formatted markdown or text reports directly into your Dropbox. ## Vibe Coding Examples Try these natural language prompts to build file-handling agents instantly: "Build a legal assistant app. When I provide a file name, use the Dropbox tool to locate that contract, read its contents, and generate a bulleted list of all the hidden liabilities or termination clauses." "Create an automated file organizer. Every day, monitor my 'Unsorted Invoices' Dropbox folder. Read each document, identify the vendor name, and move the file into a subfolder named after that vendor." "I want an agent that takes a raw meeting transcript as text input, format it into clean meeting minutes with action items, and then uses the Dropbox tool to save it as a new file in the 'Team Meetings 2024' folder." Combine Dropbox with communication tools! Prompt Architect to have your agent save a generated report to Dropbox, and then immediately email the shared Dropbox link to your team using Gmail. ## Available Actions The Dropbox tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `DROPBOX_CREATE_FILE_REQUEST` * `DROPBOX_CREATE_FOLDER` * `DROPBOX_CREATE_PAPER` * `DROPBOX_DELETE_FILE_OR_FOLDER` * `DROPBOX_GET_ABOUT_ME` * `DROPBOX_LIST_FILES_IN_FOLDER` * `DROPBOX_LIST_FOLDERS` * `DROPBOX_MOVE_FILE_OR_FOLDER` * `DROPBOX_READ_FILE` * `DROPBOX_SEARCH_FILE_OR_FOLDER` * `DROPBOX_UPLOAD_FILE` # Google Calendar Source: https://docs.architect.new/integrations/workspace/google-calendar The Google Calendar tool allows your AI agents to seamlessly manage time and schedules. By integrating this tool, your Architect apps can read upcoming events, resolve scheduling conflicts, create new meetings, and invite participants automatically. ## Why Use Google Calendar in Architect? Dealing with timezones, meeting overlaps, and calendar invites is a hassle. With vibe coding, you can describe your ideal scheduling assistant, and Architect handles the complex calendar logic. The agent acts like an executive assistant, keeping your days organized without manual data entry. * **Automated Booking:** Build apps that process natural language requests like "book 30 mins with Sarah tomorrow" and instantly lock in the calendar slot. * **Smart Briefings:** Create agents that scan your daily schedule every morning and provide a contextual briefing of who you are meeting and what their company does. * **Conflict Resolution:** Have your agent automatically detect overlapping events and suggest alternative times to all participants. ## Vibe Coding Examples Try these natural language prompts to build autonomous scheduling agents: "Build a scheduling assistant. When a user asks to book a meeting, check my Google Calendar for the next available 45-minute slot during my working hours. Create the event, generate a Google Meet link, and invite the user." "Create a daily prep app. Use the Google Calendar tool to fetch all my meetings for today. For each external guest, search the web to summarize their company, and compile a prep document for me before I start my day." "I want a productivity agent. At the end of every week, scan my Google Calendar for the upcoming week. Automatically block out two 2-hour 'Deep Work' sessions on the days where my schedule is the lightest." Vibe code an end-to-end meeting workflow: Tell Architect to use Gmail to parse a client's email asking to meet, then use Google Calendar to book the time, and finally use Slack to notify you that it's done! ## Available Actions The Google Calendar tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `GOOGLECALENDAR_CALENDAR_LIST_INSERT` * `GOOGLECALENDAR_CALENDAR_LIST_UPDATE` * `GOOGLECALENDAR_CALENDARS_DELETE` * `GOOGLECALENDAR_CALENDARS_UPDATE` * `GOOGLECALENDAR_CLEAR_CALENDAR` * `GOOGLECALENDAR_CREATE_EVENT` * `GOOGLECALENDAR_DELETE_EVENT` * `GOOGLECALENDAR_DUPLICATE_CALENDAR` * `GOOGLECALENDAR_EVENTS_INSTANCES` * `GOOGLECALENDAR_EVENTS_LIST` * `GOOGLECALENDAR_EVENTS_MOVE` * `GOOGLECALENDAR_EVENTS_WATCH` * `GOOGLECALENDAR_FIND_EVENT` * `GOOGLECALENDAR_FIND_FREE_SLOTS` * `GOOGLECALENDAR_FREE_BUSY_QUERY` * `GOOGLECALENDAR_GET_CALENDAR` * `GOOGLECALENDAR_GET_CURRENT_DATE_TIME` * `GOOGLECALENDAR_LIST_ACL_RULES` * `GOOGLECALENDAR_LIST_CALENDARS` * `GOOGLECALENDAR_PATCH_CALENDAR` * `GOOGLECALENDAR_PATCH_EVENT` * `GOOGLECALENDAR_QUICK_ADD` * `GOOGLECALENDAR_REMOVE_ATTENDEE` * `GOOGLECALENDAR_SETTINGS_LIST` * `GOOGLECALENDAR_SETTINGS_WATCH` * `GOOGLECALENDAR_SYNC_EVENTS` * `GOOGLECALENDAR_UPDATE_ACL_RULE` * `GOOGLECALENDAR_UPDATE_EVENT` # Google Docs Source: https://docs.architect.new/integrations/workspace/google-docs The Google Docs tool gives your AI agents the ability to autonomously create, read, and edit documents. Instead of just generating text in a chat window, your apps can format long-form content and save it directly into living, shareable documents. ## Why Use Google Docs in Architect? Copy-pasting AI output is a thing of the past. With vibe coding, you can describe complex documentation workflows, and Architect will handle the formatting and file creation. Whether you need automated reports, dynamic proposals, or structured meeting minutes, your agent can write it straight into a Google Doc. * **Automated Reporting:** Build agents that pull data from various sources and compile it into beautifully formatted weekly reports. * **Content Generation:** Create SEO apps that research topics and draft complete, structured blog posts directly into your workspace. * **Document Review:** Have your agent read an existing Google Doc, check it against your brand guidelines, and append a summary of suggested edits. ## Vibe Coding Examples Try these natural language prompts to build automated document-generation agents: "Build a sales proposal app. I will provide a client's name and our proposed features. Expand this into a professional, 3-page sales proposal, format it with clear headings, and use the Google Docs tool to create a new document named '\[Client Name] - Proposal'." "Create a meeting minutes agent. Take a raw meeting transcript, extract the key decisions and action items, and create a new Google Doc formatted with bullet points and bold text for assigned tasks." "I want an SOP generator. When I describe a workflow in plain English, translate it into a formal step-by-step SOP document, and use the Google Docs tool to save it into my team's shared workspace." Vibe code an end-to-end research workflow! Tell Architect to use the Arxiv tool to find 5 papers on a topic, summarize them, and use the Google Docs tool to compile a polished literature review. ## Available Actions The Google Docs tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `GOOGLEDOCS_COPY_DOCUMENT` * `GOOGLEDOCS_CREATE_DOCUMENT` * `GOOGLEDOCS_CREATE_DOCUMENT_MARKDOWN` * `GOOGLEDOCS_CREATE_FOOTER` * `GOOGLEDOCS_CREATE_FOOTNOTE` * `GOOGLEDOCS_CREATE_HEADER` * `GOOGLEDOCS_CREATE_NAMED_RANGE` * `GOOGLEDOCS_CREATE_PARAGRAPH_BULLETS` * `GOOGLEDOCS_DELETE_CONTENT_RANGE` * `GOOGLEDOCS_DELETE_FOOTER` * `GOOGLEDOCS_DELETE_HEADER` * `GOOGLEDOCS_DELETE_NAMED_RANGE` * `GOOGLEDOCS_DELETE_PARAGRAPH_BULLETS` * `GOOGLEDOCS_DELETE_TABLE` * `GOOGLEDOCS_DELETE_TABLE_COLUMN` * `GOOGLEDOCS_DELETE_TABLE_ROW` * `GOOGLEDOCS_GET_CHARTS_FROM_SPREADSHEET` * `GOOGLEDOCS_GET_DOCUMENT_BY_ID` * `GOOGLEDOCS_INSERT_INLINE_IMAGE` * `GOOGLEDOCS_INSERT_PAGE_BREAK` * `GOOGLEDOCS_INSERT_TABLE_ACTION` * `GOOGLEDOCS_INSERT_TABLE_COLUMN` * `GOOGLEDOCS_INSERT_TEXT_ACTION` * `GOOGLEDOCS_LIST_SPREADSHEET_CHARTS_ACTION` * `GOOGLEDOCS_REPLACE_ALL_TEXT` * `GOOGLEDOCS_REPLACE_IMAGE` * `GOOGLEDOCS_SEARCH_DOCUMENTS` * `GOOGLEDOCS_UNMERGE_TABLE_CELLS` * `GOOGLEDOCS_UPDATE_DOCUMENT_MARKDOWN` * `GOOGLEDOCS_UPDATE_DOCUMENT_STYLE` * `GOOGLEDOCS_UPDATE_EXISTING_DOCUMENT` * `GOOGLEDOCS_UPDATE_TABLE_ROW_STYLE` # Google Drive Source: https://docs.architect.new/integrations/workspace/google-drive The Google Drive tool gives your AI agents complete control over your cloud storage. By connecting Google Drive to Architect, your apps can autonomously search for files, create nested folder structures, move documents, and manage permissions. ## Why Use Google Drive in Architect? Digital clutter slows teams down. Through vibe coding, you can describe your ideal file management system, and your agent will enforce it. Whether it's sorting a chaotic "Downloads" folder, fetching context from historical project files, or setting up client directories automatically, the Google Drive tool handles the heavy lifting. * **Intelligent Organization:** Build agents that scan incoming files, determine their context (e.g., 'Invoice' vs. 'Contract'), and move them to the correct Drive folders. * **Knowledge Retrieval:** Create research assistants that can search your entire Google Drive for specific keywords or past reports to answer complex questions. * **Automated Onboarding:** Have an agent automatically generate a specific set of shared folders and starter templates whenever a new client is signed. ## Vibe Coding Examples Try these natural language prompts to build autonomous file managers: "Build a project setup app. When I input a new client name, use the Google Drive tool to create a main folder for them, and then create subfolders inside it named 'Contracts', 'Assets', and 'Deliverables'." "Create an automated sorter. Look at all the files in my 'Unsorted' Google Drive folder. If a file title contains the word 'Invoice' or 'Receipt', move it to the '2024 Financials' folder." "I want a QA bot. When I ask a question about our internal policies, use the Google Drive tool to search my 'HR Documents' folder, find the most relevant PDF, read it, and answer my question based solely on that file." Use Google Drive in tandem with Slack. Prompt your agent to automatically upload a finished report to Drive, generate a shareable link, and post that link into your team's Slack channel! ## Available Actions The Google Drive tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `GOOGLEDRIVE_ADD_FILE_SHARING_PREFERENCE` * `GOOGLEDRIVE_COPY_FILE` * `GOOGLEDRIVE_CREATE_COMMENT` * `GOOGLEDRIVE_CREATE_DRIVE` * `GOOGLEDRIVE_CREATE_FILE` * `GOOGLEDRIVE_CREATE_FILE_FROM_TEXT` * `GOOGLEDRIVE_CREATE_FOLDER` * `GOOGLEDRIVE_CREATE_REPLY` * `GOOGLEDRIVE_CREATE_SHORTCUT_TO_FILE` * `GOOGLEDRIVE_DELETE_COMMENT` * `GOOGLEDRIVE_DELETE_DRIVE` * `GOOGLEDRIVE_DELETE_PERMISSION` * `GOOGLEDRIVE_DELETE_REPLY` * `GOOGLEDRIVE_DOWNLOAD_FILE` * `GOOGLEDRIVE_EDIT_FILE` * `GOOGLEDRIVE_EMPTY_TRASH` * `GOOGLEDRIVE_FILES_MODIFY_LABELS` * `GOOGLEDRIVE_FIND_FILE` * `GOOGLEDRIVE_FIND_FOLDER` * `GOOGLEDRIVE_GENERATE_IDS` * `GOOGLEDRIVE_GET_ABOUT` * `GOOGLEDRIVE_GET_CHANGES_START_PAGE_TOKEN` * `GOOGLEDRIVE_GET_COMMENT` * `GOOGLEDRIVE_GET_DRIVE` * `GOOGLEDRIVE_GET_FILE_METADATA` * `GOOGLEDRIVE_GET_PERMISSION` * `GOOGLEDRIVE_GET_REPLY` * `GOOGLEDRIVE_GET_REVISION` * `GOOGLEDRIVE_GOOGLE_DRIVE_DELETE_FOLDER_OR_FILE_ACTION` * `GOOGLEDRIVE_HIDE_DRIVE` * `GOOGLEDRIVE_LIST_CHANGES` * `GOOGLEDRIVE_LIST_COMMENTS` * `GOOGLEDRIVE_LIST_FILE_LABELS` * `GOOGLEDRIVE_LIST_FILES` * `GOOGLEDRIVE_LIST_PERMISSIONS` * `GOOGLEDRIVE_LIST_REPLIES_TO_COMMENT` * `GOOGLEDRIVE_LIST_REVISIONS` * `GOOGLEDRIVE_LIST_SHARED_DRIVES` * `GOOGLEDRIVE_MOVE_FILE` * `GOOGLEDRIVE_PARSE_FILE` * `GOOGLEDRIVE_STOP_WATCH_CHANNEL` * `GOOGLEDRIVE_UNHIDE_DRIVE` * `GOOGLEDRIVE_UNTRASH_FILE` * `GOOGLEDRIVE_UPDATE_COMMENT` * `GOOGLEDRIVE_UPDATE_DRIVE` * `GOOGLEDRIVE_UPDATE_FILE_PUT` * `GOOGLEDRIVE_UPDATE_FILE_REVISION_METADATA` * `GOOGLEDRIVE_UPDATE_PERMISSION` * `GOOGLEDRIVE_UPDATE_REPLY` * `GOOGLEDRIVE_UPLOAD_FILE` * `GOOGLEDRIVE_WATCH_CHANGES` # Notion Source: https://docs.architect.new/integrations/workspace/notion The Notion tool connects your AI agents directly to your team's knowledge workspace. By integrating Notion into Architect, your apps can autonomously create pages, update databases, organize documentation, and retrieve company knowledge. ## Why Use Notion in Architect? Notion is the brain of many companies, but keeping it updated is a chore. With vibe coding, your AI can act as a dedicated knowledge manager. You describe how information should be captured or organized, and your agent ensures it's perfectly formatted and placed in the right Notion databases. * **Automated Documentation:** Turn rough meeting transcripts or voice notes into beautifully structured Notion pages with action items and summaries. * **Database Management:** Build agents that read incoming form submissions or emails and automatically populate a Notion CRM or task tracker. * **Knowledge Retrieval:** Create internal support bots that search your Notion workspace to answer employee questions instantly. ## Vibe Coding Examples Try these natural language prompts to build autonomous workspace agents: "Build an assistant that takes raw Zoom transcripts, extracts key decisions, and uses the Notion tool to create a perfectly formatted meeting minute page in our 'Engineering Syncs' database." "Create a QA bot. When a user reports a bug in Slack, use the Notion tool to add a new row to our 'Issue Tracker' database with the status 'To Do' and tag the relevant team." "I want an HR bot. When a new hire asks about the vacation policy, use the Notion tool to search our company wiki, retrieve the exact policy text, and summarize it for them." Combine Notion with Slack! Vibe code an agent that drafts a weekly project update in Notion and automatically posts the link and a summary to your #general Slack channel! ## Available Actions The Notion tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `NOTION_ADD_MULTIPLE_PAGE_CONTENT` * `NOTION_ADD_PAGE_CONTENT` * `NOTION_APPEND_BLOCK_CHILDREN` * `NOTION_ARCHIVE_NOTION_PAGE` * `NOTION_CREATE_COMMENT` * `NOTION_CREATE_DATABASE` * `NOTION_CREATE_NOTION_PAGE` * `NOTION_DELETE_BLOCK` * `NOTION_DUPLICATE_PAGE` * `NOTION_FETCH_BLOCK_CONTENTS` * `NOTION_FETCH_BLOCK_METADATA` * `NOTION_FETCH_COMMENTS` * `NOTION_FETCH_DATA` * `NOTION_FETCH_DATABASE` * `NOTION_FETCH_ROW` * `NOTION_GET_ABOUT_ME` * `NOTION_GET_ABOUT_USER` * `NOTION_GET_PAGE_PROPERTY_ACTION` * `NOTION_INSERT_ROW_DATABASE` * `NOTION_LIST_USERS` * `NOTION_QUERY_DATABASE` * `NOTION_RETRIEVE_COMMENT` * `NOTION_RETRIEVE_DATABASE_PROPERTY` * `NOTION_SEARCH_NOTION_PAGE` * `NOTION_UPDATE_BLOCK` * `NOTION_UPDATE_PAGE` * `NOTION_UPDATE_ROW_DATABASE` * `NOTION_UPDATE_SCHEMA_DATABASE` # Trello Source: https://docs.architect.new/integrations/workspace/trello The Trello tool connects your AI agents directly to your Kanban boards. By integrating Trello with Architect, your apps can autonomously create cards, move tasks between lists, assign members, and manage your visual project pipelines without any manual drag-and-drop. ## Why Use Trello in Architect? Visual project management is great, but maintaining the boards can become a chore. With Architect's vibe coding, you can describe how your workflow should operate, and your agent will act as a tireless project manager. It ensures your boards are always up-to-date, automatically reflecting the actual state of your work. * **Automated Card Creation:** Turn emails, form submissions, or meeting notes into perfectly formatted Trello cards in your 'Inbox' or 'To Do' list. * **Dynamic Status Updates:** Build agents that monitor your code repository or CRM and automatically move Trello cards from 'In Progress' to 'Done'. * **Board Auditing:** Have your agent scan your Trello board at the end of the week to identify stale cards that haven't moved in 14 days and flag them for review. ## Vibe Coding Examples Try these natural language prompts to build autonomous Kanban agents: "Build a blog management app. When a freelance writer submits a Google Doc link, use the Trello tool to create a new card in the 'Ready for Review' list. Attach the link, add a 'Content' label, and assign it to the Managing Editor." "Create a bug tracking bot. Analyze incoming customer complaints. If it is a verified bug, use the Trello tool to create a card in the 'Urgent Fixes' list, generate a summary of how to reproduce the error in the description, and assign a red priority label." "I want a morning standup assistant. Use the Trello tool to read all the cards currently sitting in the 'Doing' list across our engineering board. Generate a bulleted list of what the team is focusing on today." Combine Trello with communication tools! Vibe code an agent that uses Trello to move a task to "Completed" and then automatically uses Slack to notify the person who originally requested the task! ## Available Actions The Trello tool exposes the following actions to your agents. Architect automatically picks the right one based on your prompt. * `TRELLO_ACTION_GET_BOARD_BY_ID_ACTION` * `TRELLO_ACTION_GET_BY_ID` * `TRELLO_ACTION_GET_LIST_BY_ID_ACTION` * `TRELLO_ADD_BOARDS` * `TRELLO_ADD_BOARDS_CALENDAR_KEY_GENERATE_BY_ID_BOARD` * `TRELLO_ADD_BOARDS_CHECKLISTS_BY_ID_BOARD` * `TRELLO_ADD_BOARDS_EMAIL_KEY_GENERATE_BY_ID_BOARD` * `TRELLO_ADD_BOARDS_LABELS_BY_ID_BOARD` * `TRELLO_ADD_BOARDS_LISTS_BY_ID_BOARD` * `TRELLO_ADD_BOARDS_MARK_AS_VIEWED_BY_ID_BOARD` * `TRELLO_ADD_BOARDS_POWER_UPS_BY_ID_BOARD` * `TRELLO_ADD_CARDS` * `TRELLO_ADD_CARDS_ACTIONS_COMMENTS_BY_ID_CARD` * `TRELLO_ADD_CARDS_ATTACHMENTS_BY_ID_CARD` * `TRELLO_ADD_CARDS_CHECKLIST_CHECK_ITEM_BY_ID_CARD_BY_ID_CHECKLIST` * `TRELLO_ADD_CARDS_CHECKLISTS_BY_ID_CARD` * `TRELLO_ADD_CARDS_ID_LABELS_BY_ID_CARD` * `TRELLO_ADD_CARDS_ID_MEMBERS_BY_ID_CARD` * `TRELLO_ADD_CARDS_LABELS_BY_ID_CARD` * `TRELLO_ADD_CARDS_MEMBERS_VOTED_BY_ID_CARD` * `TRELLO_ADD_CARDS_STICKERS_BY_ID_CARD` * `TRELLO_ADD_CHECKLISTS` * `TRELLO_ADD_CHECKLISTS_CHECK_ITEMS_BY_ID_CHECKLIST` * `TRELLO_ADD_LABELS` * `TRELLO_ADD_LISTS` * `TRELLO_ADD_LISTS_ARCHIVE_ALL_CARDS_BY_ID_LIST` * `TRELLO_ADD_LISTS_CARDS_BY_ID_LIST` * `TRELLO_ADD_LISTS_MOVE_ALL_CARDS_BY_ID_LIST` * `TRELLO_ADD_MEMBERS_AVATAR_BY_ID_MEMBER` * `TRELLO_ADD_MEMBERS_BOARD_BACKGROUNDS_BY_ID_MEMBER` * `TRELLO_ADD_MEMBERS_BOARD_STARS_BY_ID_MEMBER` * `TRELLO_ADD_MEMBERS_CUSTOM_BOARD_BACKGROUNDS_BY_ID_MEMBER` * `TRELLO_ADD_MEMBERS_CUSTOM_EMOJI_BY_ID_MEMBER` * `TRELLO_ADD_MEMBERS_CUSTOM_STICKERS_BY_ID_MEMBER` * `TRELLO_ADD_MEMBERS_SAVED_SEARCHES_BY_ID_MEMBER` * `TRELLO_ADD_NOTIFICATIONS_ALL_READ` * `TRELLO_ADD_ORGANIZATIONS` * `TRELLO_ADD_ORGANIZATIONS_LOGO_BY_ID_ORG` * `TRELLO_ADD_SESSIONS` * `TRELLO_ADD_TOKENS_WEBHOOKS_BY_TOKEN` * `TRELLO_BOARD_CREATE_BOARD` * `TRELLO_BOARD_FILTER_CARDS_BY_ID_BOARD` * `TRELLO_BOARD_GET_BY_ID` * `TRELLO_BOARD_GET_CARDS_BY_ID_BOARD` * `TRELLO_BOARD_GET_LISTS_BY_ID_BOARD` * `TRELLO_CARD_CREATE_AND_UPDATE` * `TRELLO_CARD_GET_BY_ID` * `TRELLO_CARD_GET_BY_ID_FIELD` * `TRELLO_CARD_UPDATE_BY_ID_CARD` * `TRELLO_CARD_UPDATE_ID_LIST_BY_ID_CARD` * `TRELLO_CARD_UPDATE_POS_BY_ID_CARD` * `TRELLO_CONVERT_CHECKLIST_ITEM_TO_CARD` * `TRELLO_DELETE_ACTIONS_BY_ID_ACTION` * `TRELLO_DELETE_BOARDS_MEMBERS_BY_ID_BOARD_BY_ID_MEMBER` * `TRELLO_DELETE_BOARDS_POWER_UPS_BY_ID_BOARD_BY_POWER_UP` * `TRELLO_DELETE_CARDS_ACTIONS_COMMENTS_BY_ID_CARD_BY_ID_ACTION` * `TRELLO_DELETE_CARDS_ATTACHMENTS_BY_ID_CARD_BY_ID_ATTACHMENT` * `TRELLO_DELETE_CARDS_BY_ID_CARD` * `TRELLO_DELETE_CARDS_CHECKLISTS_BY_ID_CARD_BY_ID_CHECKLIST` * `TRELLO_DELETE_CARDS_ID_LABELS_BY_ID_CARD_BY_ID_LABEL` * `TRELLO_DELETE_CARDS_ID_MEMBERS_BY_ID_CARD_BY_ID_MEMBER` * `TRELLO_DELETE_CARDS_LABELS_BY_ID_CARD_BY_COLOR` * `TRELLO_DELETE_CARDS_MEMBERS_VOTED_BY_ID_CARD_BY_ID_MEMBER` * `TRELLO_DELETE_CARDS_STICKERS_BY_ID_CARD_BY_ID_STICKER` * `TRELLO_DELETE_CHECKLIST_ITEM` * `TRELLO_DELETE_CHECKLISTS_BY_ID_CHECKLIST` * `TRELLO_DELETE_LABELS_BY_ID_LABEL` * `TRELLO_DELETE_MEMBER_BOARD_BACKGROUND` * `TRELLO_DELETE_MEMBER_CUSTOM_STICKER` * `TRELLO_DELETE_MEMBER_SAVED_SEARCH` * `TRELLO_DELETE_MEMBERS_BOARD_STARS_BY_ID_MEMBER_BY_ID_BOARD_STAR` * `TRELLO_DELETE_ORGANIZATIONS_BY_ID_ORG` * `TRELLO_DELETE_ORGANIZATIONS_LOGO_BY_ID_ORG` * `TRELLO_DELETE_ORGANIZATIONS_MEMBERS_ALL_BY_ID_ORG_BY_ID_MEMBER` * `TRELLO_DELETE_ORGANIZATIONS_MEMBERS_BY_ID_ORG_BY_ID_MEMBER` * `TRELLO_DELETE_ORGANIZATIONS_PREFS_ORG_INVITE_RESTRICT_BY_ID_ORG` * `TRELLO_DELETE_ORG_ASSOCIATED_DOMAIN` * `TRELLO_DELETE_TOKENS_BY_TOKEN` * `TRELLO_DELETE_TOKENS_WEBHOOKS_BY_TOKEN_BY_ID_WEBHOOK` * `TRELLO_DELETE_WEBHOOKS_BY_ID_WEBHOOK` * `TRELLO_DISMISS_MEMBER_MESSAGE` * `TRELLO_GET_ACTIONS_BOARD_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_BOARD_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_ACTIONS_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_ACTIONS_CARD_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_CARD_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_ACTIONS_DISPLAY_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_ENTITIES_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_LIST_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_LIST_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_ACTIONS_MEMBER_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_MEMBER_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_ACTIONS_MEMBER_CREATOR_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_MEMBER_CREATOR_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_ACTIONS_ORGANIZATION_BY_ID_ACTION` * `TRELLO_GET_ACTIONS_ORGANIZATION_BY_ID_ACTION_BY_FIELD` * `TRELLO_GET_BATCH` * `TRELLO_GET_BOARDS_ACTIONS_BY_ID_BOARD` * `TRELLO_GET_BOARDS_BOARD_STARS_BY_ID_BOARD` # Help & Support Source: https://docs.architect.new/introduction/essentials/help-support Stuck on something? Reach out to the Architect team directly from inside the product — via a support form or live chat. ## Help & Support Form For any query, question, or issue, click the **Help & Support** button at the **bottom-left of the homepage sidebar**. This opens a form where you can describe what you're running into, and our team will get back to you over email. Help & Support form accessible from the homepage sidebar ## Live Chat for Real-Time Help Need something answered right away? Click the **mascot icon floating at the bottom-right of the screen** to open a live chat and ask your query. This is the fastest way to get real-time support while you're building. Live chat opened from the mascot icon at the bottom-right of the screen # Plans & Credits Source: https://docs.architect.new/introduction/essentials/plans-credits Architect is integrated directly with the Lyzr ecosystem. One unified profile for all your projects. ## Account Setup To access Architect, you simply need to sign in. Your credits and projects are managed under a single unified profile automatically. **Direct Sign-up:** [https://architect.new/ ↗](https://architect.new/) ## Choose Your Plan Pick the plan that fits how you build. Every paid plan includes a monthly pool of credits that your agents spend as they run — and you can switch between **Monthly** and **Annual** billing right from the picker (annual saves \~12%). The Choose Your Plan screen showing the Free, Starter, Pro, Max, and Custom plans Use the tabs below for the full plan-by-plan breakdown. Perfect to explore and build your first agents. **Free credits included** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ❌ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ❌ Priority support Billed monthly. **\$20 credits each month** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Billed monthly. **\$40 credits each month** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Billed monthly. **\$99 credits each month** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Tailored to your organization's needs. **Custom credits allocation** * ✅ **Exclusive support from Team Lyzr** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Perfect to explore and build your first agents. **Free credits included** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ❌ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ❌ Priority support Billed annually — save \$40/year. **\$20 credits each month** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Billed annually — save \$60/year. **\$40 credits each month** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Billed annually — save \$189/year. **\$99 credits each month** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support Tailored to your organization's needs. **Custom credits allocation** * ✅ **Exclusive support from Team Lyzr** * ✅ Access to Agent Marketplace * ✅ Deploy your agents * ✅ Publish to Marketplace * ✅ Remove 'Built with Architect' watermark * ✅ Custom agent branding (Soon) * ✅ Analytics dashboard (Soon) * ✅ Priority support ## Need help choosing? If you have specific requirements for credit allocation or need an Enterprise agreement, our team is here to help. Book a demo or talk to our sales team. Chat with the community and developers. # Getting Ready Source: https://docs.architect.new/introduction/essentials/prerequisites Architect removes the technical barriers. You don't need API keys, local environments, or Git repos. You just need an account and an idea. ## The Checklist **Required** The only technical step. Sign up for Architect, and your Lyzr Studio Account is automatically created. This gives you seamless access to both Architect and Studio. [Sign Up / Login to Architect ↗](https://architect.new) **Critical** The AI is powerful, but it's not telepathic. The quality of your app depends on the clarity of your instructions. * ❌ "Build a CRM" * ✅ "Build a CRM for dentists to track patient follow-ups" **Optional** If you want your app to answer questions about specific documents, have your PDFs, CSVs, or text files ready to upload. `.pdf` `.csv` `.docx` ## Preparation Tip: The "5-Minute Rule" Before you open Architect, spend 5 minutes writing down what you want. You don't need technical specs, but you should know: Who is the user? (e.g., "A Sales Manager") What is the input? (e.g., "Uploads a CSV of leads") What is the result? (e.g., "A chart showing revenue") ## Ready to launch? If you have your account ready, jump straight into the builder. Start building your first agentic app now. # Best Use Cases Source: https://docs.architect.new/introduction/overview/best-use-cases Architect shines wherever an app needs to think, reason, research, or talk — not just render CRUD forms. Here's how to know if your idea is a great fit. ## The Core Rule If your app needs **agentic thinking** — reasoning, analysis, research, or domain expertise — Architect is the right tool. Architect was purpose-built to orchestrate multiple AI agents, tools, and data sources behind a polished UI, which makes it dramatically better than general-purpose vibe coding tools for any use case where intelligence is the product. Rule of thumb: if a human currently does this task using their brain (reading, deciding, summarizing, advising, interviewing), Architect is likely the best way to automate it. ## Where Architect Excels Apps where the AI has to plan, decide between options, or chain multiple steps to reach an outcome — not just generate a single response. Apps that ingest data (documents, spreadsheets, tickets, logs) and produce structured analysis, comparisons, scorecards, or recommendations. Apps that search, read, and synthesize information from the web, internal docs, or external APIs — and deliver a concise, cited answer. Conversational agents that handle calls, interviews, or voice-driven workflows end-to-end — with real-time reasoning built in. Apps that encode specialist knowledge — legal, medical, financial, HR, compliance — and apply it consistently to every request. Apps that coordinate several tools (Gmail + HubSpot + Slack, for example) and make autonomous decisions about what to do next. ## Example Fits * Resume screeners that score candidates against a rubric and draft rejection or interview emails * Contract reviewers that flag risky clauses and suggest redlines * Financial statement analyzers that extract KPIs and compare against benchmarks * Support ticket triagers that categorize, prioritize, and route incoming requests * Market research assistants that pull competitor data and produce a briefing * Academic literature reviewers (pair with the Arxiv integration) * Due-diligence agents that compile a company profile from public sources * News digest agents that summarize overnight developments in your industry * Voice-based lead qualification agents for inbound calls * Interview bots that conduct structured candidate screenings * Voice-driven internal assistants (HR helpdesk, IT support) * Survey agents that collect structured feedback over phone or chat * Legal intake assistants that pre-qualify cases and draft engagement letters * Clinical scribes that convert conversation transcripts into structured notes * Compliance reviewers that check deliverables against regulatory checklists * Financial advisors that tailor recommendations to a client's portfolio * Sales outreach agents: find leads (Apollo) → email (Gmail) → log (HubSpot) * Incident responders: detect issue → diagnose → notify (Slack) → file ticket (Linear) * Content pipelines: research → draft → post to LinkedIn / Twitter * Meeting coordinators: parse email → check Google Calendar → book → confirm ## When Architect May Not Be the Best Fit Architect is a powerhouse for *intelligent* apps. It's **not** the ideal tool for: * Pure **static websites** (marketing pages, portfolios) — use a traditional website builder. * Simple **CRUD apps** with no AI component — a low-code tool may be faster. * Heavy **real-time multiplayer** apps (collaborative editors, live games) — these need specialized infrastructure. If your idea involves zero reasoning or zero domain knowledge, you probably don't need an agentic platform. Not sure whether your idea fits? Open the **AI Consultant** in Architect and describe your goal — it'll tell you whether Architect is the right fit and suggest the agent architecture. ## Next Step Once you've confirmed your idea is a good fit, head to the [Build Guide](/build/build-guide) to turn it into a deployed app. # Introduction Source: https://docs.architect.new/introduction/overview/introduction Turn Intent into Deployed Applications Lyzr Architect is an enterprise-grade **Text-to-App** platform. It transforms natural-language prompts into fully functional, full-stack agentic applications — powered by multi-agent orchestration, and ready to share with a live URL. You describe what you want in plain English. Architect plans it with you, designs the interface, creates the AI agents that power it, writes the front-end and back-end, fixes its own errors, and deploys the result — without you touching a line of code or configuring any infrastructure. Lyzr Architect Interface ## What makes Architect different? Most "AI coding tools" are really just autocomplete engines — they help you write functions faster, but you're still the one stitching the system together, wiring up the backend, and figuring out how to deploy it. **Lyzr Architect is a System Builder.** From a single prompt, it autonomously engineers the front-end, the agentic middle layer, and the data and tooling underneath — then runs, tests, and ships it as one deterministic workflow. Stop worrying about syntax. Describe the *vibe*, the business logic, and the user flow in plain English, and Architect translates your intent into production-ready code. It doesn't just write scripts. It builds a complete front-end, an intelligent agentic middle layer, and plugs in the tooling and knowledge bases your use case actually needs. Architect uses Lyzr Studio to spin up autonomous agents — researchers, writers, analysts — and wires them directly into your app's backend. A built-in QA loop runs the code Architect generates. If something fails a type check or throws a console error, it rewrites the code and re-checks before ever showing you the app. ## How a Build Flows Every app follows the same path — and you stay in control at each stage: Before any code is written, you shape the idea with Architect — refine the requirements, preview how the app will look, and generate supporting artifacts. See [Planning & Brainstorming](/build/planning-brainstorming). Architect creates the agents, writes the UI and backend, and self-heals errors until the app runs in a live preview. Chat to iterate — or flip into [Plan Mode](/build/plan-mode) to map out a bigger change before building it. Ship to a live, shareable URL, or connect your own custom domain. See [Deployment & Publishing](/build/deployment). New here? The Build Guide walks you through creating your first agentic app, end to end. # Why Architect? Source: https://docs.architect.new/introduction/overview/why-architect The software landscape has shifted. Building apps is no longer about writing boilerplate; it is about orchestrating intelligence. The software landscape has shifted. Building an app is no longer about writing boilerplate — it's about orchestrating intelligence. Architect exists because the modern "AI app" stack is powerful but painfully fragmented, and most of the teams who need these tools the most can't afford to assemble that stack themselves. ## The Fragmentation Problem Before Architect, building an "Agentic App" (say, an automated legal reviewer) meant stitching together a disjointed, complex stack — and maintaining every piece of it: * **LangChain / LlamaIndex** for agent logic and orchestration * **Pinecone / Weaviate** for vector memory and retrieval * **FastAPI** to expose your agents as endpoints * **React / Next.js** for the user interface * **Auth, a database, hosting, and CI/CD** to actually ship it Each layer needs its own setup, glue code, and ongoing upkeep — and a single engineer has to understand all of them. **Outcome: 6+ weeks.** Typical time to a working MVP for a single internal tool — gated on scarce engineering time and a high upfront cost before you've even validated the idea. ## The Architect Advantage Architect unifies that entire stack behind a single prompt. The agent logic, the vector memory, the API layer, the UI, the auth, the database, and the hosting are all handled for you — so Product Managers, Founders, and non-engineering teams can self-serve complex software needs without waiting on an engineering queue. In the enterprise, the backlog is the enemy — internal tools often sit there for months. Architect cuts build time from weeks to minutes, letting you bypass the backlog entirely and validate ideas the same day you have them. AI code generators love to hallucinate packages and ship broken builds. Architect runs a multi-agent validation loop instead: it writes the code, runs it, reads the errors, fixes them, and only then shows you a working app. No environments, API keys, or framework decisions to make. If you can describe the outcome you want, you can build and ship the app that delivers it. Architect isn't a black box. Every app is real React/Next.js + Lyzr backend code you can push to your own GitHub, export, and self-host. ### Comparison: Traditional Dev vs. Lyzr Architect | Feature | Traditional AI Dev | Lyzr Architect | | :-------------------- | :------------------------ | :------------------------------ | | **Setup Time** | Days (Env, Git, API keys) | **Instant (Zero setup)** | | **Agent Integration** | Manual (LangChain code) | **Automated (Lyzr Agentic OS)** | | **Frontend** | Manual (React/Vue) | **Auto-Generated (Shadcn UI)** | | **Cost to Build** | \$10k+ (Eng hours) | **\~\$10 (Compute credits)** | # Marketplace Source: https://docs.architect.new/introduction/platform/agentlets Discover, explore, and clone hundreds of community-built agentic applications from the Lyzr Architect ecosystem. ## The Community Ecosystem Architect is more than just a builder; it is a thriving ecosystem. The **Marketplace** is a global directory where you can discover applications built by other professionals, developers, and creators. Instead of reinventing the wheel, you can browse the marketplace to find an app that already solves your problem, or use community apps as inspiration for your own builds. The Marketplace showing community-built apps with category and use-case filters ## Browsing the Marketplace With hundreds of active apps (and growing daily), the Marketplace gives you a search bar plus granular filters — and sorting by **Popular**, **Recent**, or **Top Rated** — to help you find exactly what you need. Filter apps by their primary domain, such as: * Automation * Analytics & Insights * Customer Support * Finance & Accounting * HR & Recruiting * Marketing Narrow down solutions based on the specific action they perform: * Lead Generation * Customer Engagement * Workflow Automation * Data Analysis * Content Creation ## Interacting with Marketplace Apps When you find an application that looks promising (like `study-autopilot`, `claim-guard`, or `agent-marketeam`), you can: 1. **Preview:** View the application's interface and understand its core workflow. 2. **Analyze:** See how the creator structured their agents and prompts. 3. **Clone & Modify (Coming Soon):** Fork the application into your own workspace to tweak the branding, adjust the agent instructions, or connect your own proprietary Knowledge Bases. Built something worth sharing? You can publish your own app to the Marketplace at deploy time — see **Publish to Marketplace** in [Deployment & Publishing](/build/deployment). # The AI Consultant Source: https://docs.architect.new/introduction/platform/ai-consultant No prompt? No problem. The AI Consultant interviews you like a seasoned product manager — learning your role, your biggest time-sinks, and the tools you use — then hands you ready-to-build agents with real time-savings estimates. Open **"What should I build?"** from the homepage sidebar to launch a guided interview. There's no need for technical specs or a fully-formed idea — Architect starts by getting to know *you* and how you actually work. The 'What should I build?' button in the homepage sidebar A short, four-part conversation that turns what you do every day into a concrete spec for what Architect should build. ### Your Identity Architect starts with who you are. These details personalize the app it builds for you — like greeting you by name in the dashboard header. Identity step — 'Tell us about yourself' ### Your Role Tell Architect your job function and it cross-references your role against a library of common, industry-specific bottlenecks — so its suggestions feel tailored to your work, not generic. Role selection step asking 'What's your role?' with role cards ### Your Time-Sinks The most important step. Architect asks where your time actually goes and surfaces the repetitive tasks that drain your week — the raw material it uses to estimate how many hours an agent could give back. Pain point discovery step asking 'What takes up your time?' with role-specific time sinks ### Tool Integrations Architect asks which tools you already rely on — Slack, HubSpot, Jira, and more — so the agents it recommends plug into your existing stack instead of living in a silo. Tool integrations step asking 'What tools do you use?' with selectable app options Architect doesn't stop at a vague idea — it returns a spec. Based on everything you shared, it generates three tailored agent proposals, each with a clear purpose, a list of capabilities, and an estimate of the hours it saves you every week. Pick one and start building in a single click. Recommended Agents proposals with capability lists and weekly time-savings estimates From idea to a spec Tailored agent proposals From proposal to PRD # Architect + Studio Source: https://docs.architect.new/introduction/platform/architect-vs-studio They aren't separate tools; they are stages in your product lifecycle. Use Architect to ignite the idea, and Studio to engineer the scale. Architect and Lyzr Studio aren't competing products — they're two stages of the same product lifecycle. Architect gets you from an idea to a working, deployed app in minutes. Studio is where you go afterward to deepen and harden the intelligence behind it. Because Architect builds **real Studio agents** under the hood, moving between the two is seamless: the agents you see in Studio are the same ones powering your live app. | | **Architect** | **Lyzr Studio** | | :---------------- | :----------------------------- | :---------------------------------------- | | **Best for** | Going from idea → deployed app | Maturing and scaling the backend | | **You control** | The prompt, the UI, the data | System prompts, models, tools, governance | | **Optimized for** | Speed & discovery | Depth & production-readiness | | **Output** | A live, shareable web app | Hardened, observable agent endpoints | ## The Prototyping Engine (Architect) Architect is designed for **Speed** and **Discovery**. It handles the heavy lifting of initial setup, allowing you to go from a vague "vibe" to a working full-stack application in minutes. You don't need to know which embedding model to use or how to configure vector DB schemas. Architect makes those decisions for you so you can validate the product value first. A fully deployed web URL with a custom React frontend. It's ready to show to investors, stakeholders, or early users immediately. ## The Scaling Engine (Studio) Once your Architect app is validated, **Lyzr Studio** is where you go to mature the backend. Since Architect creates real Studio agents under the hood, you can seamlessly transition to Studio to fine-tune the intelligence. You need deeper control. Maybe you want to switch from GPT-4o to Claude 3.5 Sonnet for cost reasons, or you need to add a custom enterprise API tool that requires specific authentication headers. Production-hardened API endpoints with rate limiting, observability, and granular governance policies applied. ## Real World Workflow: The Lifecycle of an App You prompt Architect: *"Build a Resume Screener for HR."* Within 5 minutes, you have a working UI where you can upload PDFs and get scores. You send the link to your HR team. They love it but ask for better reasoning in the rejection emails. You log into Lyzr Studio. You see the "Resume\_Screener\_Agent" that Architect created. You edit the **System Prompt** to include specific company values. You verify the changes in the Studio playground. The Architect app (Frontend) automatically uses the updated logic from Studio. The app is now "Production Ready" with refined intelligence, while retaining the beautiful custom UI Architect built. # How It Works Source: https://docs.architect.new/introduction/platform/how-it-works Architect looks deceptively simple. Under the hood, it gives you granular control over the data your app reasons over, the agents that power it, and the design it ships with. At a glance, Architect is just a prompt box. But before you ever hit send, you can shape three things that make the difference between a generic app and exactly the one you need: the **data** your agents draw on, the **design** they're wrapped in, and the **agents** themselves. This page walks through those controls. Main Interface ## Context Injection (RAG) Your app shouldn't start empty. Ground your agents in your own proprietary data using the **Attach** feature — open the **+** menu in the prompt box and add your files. Architect detects the file type and wires it into the right place automatically: * **Unstructured data (PDF / DOCX / TXT):** Automatically chunked and embedded into a vector database, so your agents can semantically search and cite your documents when they answer. * **Structured data (CSV / Excel):** Loaded into a dataframe that a data-analyst agent can query, aggregate, and visualize. The result is an app that reasons over *your* content from the very first message — no manual ingestion pipeline required. Attachment Interface ## Visual Personality Architect doesn't just generate code — it designs it. The **Theme Engine** injects a full design system (Tailwind config + fonts + component styling) into the code it writes, so every app comes out looking polished and on-brand rather than like a default template. You have two ways to set the look: * **Pick a preset** — choose from 45+ ready-made themes covering everything from clean and minimal to bold and editorial. * **Bring your own** — turn your company's design guidelines into a reusable theme by importing them from Figma, a PDF, a GitHub repo, or a zip. See [Bring Your Own Design System](/build/custom-theme). Select a theme from the **+** menu before you build, and Architect applies it consistently across the whole generated app. Theme Selector ## Prompt Library Struggling to articulate your requirements? Architect provides a context-aware **Prompt Library** in the homepage sidebar — a curated set of pre-engineered prompts known to produce high-quality agentic workflows. Browse by role or task, load one with a click, and edit it to fit your context. See [Prompt Library](/build/prompt-library) for more. Templates ## Add Studio Agents Already have agents built in Lyzr Studio? You don't need to rebuild them. Architect lets you import any existing Studio agent directly into your app, so you can compose new experiences on top of work you've already done — your custom prompts, tools, and knowledge bases all carry over as-is. Add studio agents option in the homepage menu From the **+** menu on the homepage, select **Add studio agents** to browse and pick from your existing agents. Architect wires the selected agent into the app it generates, intelligence intact. Choose Agent modal showing the list of existing Studio agents # Usage Source: https://docs.architect.new/introduction/platform/usage Track credit consumption across every app you've built with Architect from a single dashboard. Credits are how Architect meters the AI work behind your apps. Everything that calls a model — building and refining an app, and the agents inside your deployed apps as real users run them — draws from your credit balance. The **Usage** dashboard is where you keep an eye on all of it in one place. ## What Consumes Credits * **Building & refining** — each time Architect plans, generates, or edits an app, the underlying model calls consume credits. * **Running your apps** — every time an agent in a live app responds to a user, that inference consumes credits too. Because consumption scales with how much your agents actually *think*, heavier or higher-traffic apps naturally use more credits than light ones. ## Track Your Credit Usage To see exactly where your credits are going, open the **Usage** tab from the homepage sidebar. Usage tab in the Architect homepage sidebar The **Usage Breakdown** view gives you the full picture at a glance: * **Total credits used** across your account. * **Total number of apps** you've built. * A **per-app breakdown** showing how many credits each app has consumed and when it was last used — so you can quickly spot which apps are driving most of your usage. Use the search box to find a specific app, and the per-app rows to identify anything consuming more than you'd expect. Usage Breakdown page showing credit consumption per app Running low, or want a bigger monthly allotment? Review the available plans and credit allowances on [Plans & Credits](/introduction/essentials/plans-credits). # Best Practices Source: https://docs.architect.new/references/best-practices Get the most out of Architect — how to prompt well, build lean, iterate fast, and connect tools reliably. ## Writing a Great First Prompt The better the context you give Architect, the better your app will be — on the first try. A strong initial prompt covers: * **What you want to build** — describe the app in plain terms. You don't need to mention agents or architecture. Architect will figure those out on its own. * **The goal** — what problem is this app solving, and for whom? * **Inputs** — what data or information will users provide? * **What the app should do** — the core functionality, step by step. * **Output** — what should the user see or receive at the end? * **Design preferences** — any branding, tone, or visual style you have in mind. * **Integrations** — if you want to connect a specific tool or MCP (e.g. Gmail, Slack, a custom API), mention it upfront so Architect builds with that context from the start. You can write a prompt in just two or three lines — but then expect to iterate more. The more clearly you define goal, inputs, outputs, and functionality upfront, the closer the first build will be to what you want. You do **not** need to tell Architect which agents to create. Just describe the app — Architect will decide the agent architecture on its own. *** ## Keep Agents Lean More agents does not mean a better app. In fact, the more agents there are, the higher the chance of hallucination and unexpected behavior. **Aim for 4–5 agents maximum for your starting point.** Even complex use cases can be handled well within this range. You can always iterate and add more agents later, but start focused. A lean, well-scoped set of agents will produce a more reliable and predictable app than a sprawling one. *** ## Before You Start Building Once you've submitted your initial prompt and Architect has generated the PRD and App Mockup, take a moment before hitting **Start Building**: 1. **Read the PRD** — check the agents Architect plans to create, the features it's scoping in, and the overall structure. If something is off, adjust in the plan phase before any code is written. 2. **Set your theme** — this is a good time to create a custom theme, import your design guidelines from Figma or GitHub, or choose a brand style. Doing it before the build means the generated app looks on-brand from the start. → [Bring Your Own Design System](/build/custom-theme) 3. **Finalize before proceeding** — once you're happy with the PRD and mockup, proceed to build agents, and then to the app. Changes made in the plan phase are much cheaper than changes made after the app is built. *** ## Connecting Tools & Integrations Architect has a built-in list of tools it can connect to directly — you'll find the full list in the [Integrations](/integrations/communication/gmail) section. To use any of these, just mention the tool in your prompt and Architect will wire it up. **For custom tools or MCPs outside that list:** * Go to **Lyzr Studio**, open the agent Architect created, and connect your custom tool or MCP there manually. * Architect creates the agents in Studio — any tool you connect in Studio will work inside the Architect app. **If a tool or MCP isn't working as expected:** * Open the agent in Lyzr Studio directly and test it by giving it a sample input. * Check whether you're getting the right output from Studio. If it doesn't work in Studio, it won't work in Architect either — Studio is where you debug the connection first. *** ## Handling Errors Most errors you'll see in the app UI are fixable by Architect automatically. If you hit something: * **Take a screenshot** of the error and paste it into the Architect chat. * Tell Architect what you were trying to do and what went wrong. * Architect will diagnose and fix it on its own in most cases — UI errors, broken components, API errors, missing data. If a response isn't coming through, a UI component isn't rendering, or an agent isn't behaving correctly — a screenshot plus a clear description is almost always enough for Architect to resolve it. *** ## Iterating on Your App Once your first version is built, keep these in mind as you refine it: * **Don't stack multiple unrelated changes in one prompt.** If you want to change the design, fix a bug, and add a new agent — send those as separate prompts. * **Club similar changes together.** If you have a few UI tweaks that are related, you can combine them into one prompt. The rule of thumb: changes that touch the same thing can be grouped; changes that touch different parts of the app should be separate. * **Redeploy when you're ready.** After iterating, check the live preview and press **Re-deploy** when you're satisfied. Changes don't go live until you redeploy. → [Deployment](/build/deployment) *** ## Advanced: GitHub for Complex Apps For high-complexity apps or team collaboration, connect your app to GitHub early: 1. **Connect GitHub** from the top-right corner of your app. → [Connecting Your GitHub](/build/github-connect) 2. Every change Architect makes is auto-committed to your repo. 3. You can clone the repo locally, work on it in your own editor, push changes back to GitHub, and pull them back into Architect. 4. Use **branch switching** to work on features in separate branches — create a branch locally, push it, and switch to it in Architect. This gives you the full flexibility of local development alongside Architect's AI-powered building. # Frequently Asked Questions Source: https://docs.architect.new/references/faqs Everything you need to know about building, deploying, and managing agentic applications with Architect. ## General Vibe coding is a new paradigm of software development where you focus on the intent, feeling, and business outcome (the "vibe") rather than the syntax or logic. Instead of writing code, you describe what you want the app to do and feel like in natural language, and Architect handles the implementation details. ChatGPT and Claude are chatbots; **Architect is a builder.** * Chatbots give you text or code snippets that you have to copy-paste and run yourself. * Architect builds, hosts, and deploys a full-stack application (Frontend + Backend + Agent Orchestration) that you can share with a URL. Architect shines at building "Agentic Workflows"—apps where multiple AI agents need to collaborate to solve a problem. **Examples:** Automated News Aggregators, Legal Document Analyzers, Automated SDR (Sales Development) Tools, HR Resume Screeners, and Personalized Travel Planners. ## Building & Refining You have two options: * **Chat with Architect:** In the chat bar, simply say, "The tone is too formal, make it casual" or "The researcher agent is missing citations." Architect will rebuild the necessary parts. * **Edit in Studio:** For deep technical control, click on any specific agent in the "Agents" visualization. This opens Lyzr Studio, where you can manually edit the system prompt, change the model (e.g., GPT-4o to Claude 3.5 Sonnet), or tweak parameters. Use a KB when your agents need to know information that isn't publicly available on the internet. **Example:** Your company's specific HR policy, a PDF of your product manual, or a CSV of your sales data. Use a Tool when your agents need to **do something external** or fetch real-time data. **Example:** Google Search (to find current events), Send Email (to notify a user), or API Connector (to push data to your CRM). ## Technical & Deployment Yes. Architect is not a walled garden. You can export the full source code (Frontend in React/Next.js, Backend in Python/Lyzr SDK) and host it on your own infrastructure if you choose. Architect is model-agnostic. By default, it selects the best model for the task (usually a mix of GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro). You can customize this preference in the Settings or individually per agent in Lyzr Studio. Yes. As soon as the "App" phase completes, Architect generates a unique, shareable URL (e.g., `app-name.architect.new`). You can share this link immediately with colleagues or users. ## Data & Privacy **No.** Architect runs on an enterprise-grade infrastructure where data privacy is paramount. Your prompts and uploaded Knowledge Base data are isolated and never used to train foundational models. Yes. For enterprise customers, Architect supports on-premise or private VPC deployment (AWS, Azure, GCP). This ensures that no data ever leaves your controlled environment. ## Still have questions? We're here to help. Reach out through any of these channels: Email our team directly for assistance. Chat with the community and developers.