How do I schedule a Factory enterprise demo and get a quote for our engineering org?

Most engineering leaders don’t want another generic AI sales call—they want to see Droids working in their stack, understand deployment options, and get a clear enterprise quote. Factory’s process for enterprise demos and pricing is built around that: short path to a tailored demo, fast scoping for your org, and clear controls for security and governance.

Below is a step‑by‑step guide to scheduling a Factory enterprise demo and getting a quote for your engineering organization.

1. Decide what you want from the Factory enterprise demo

Before you book time, it helps to be explicit about what you need the session to answer. Factory is an agent‑native platform that can touch a lot of surfaces:

Droids in your IDEs and terminals (VS Code, JetBrains, Vim)
Droids in the browser (no local setup)
Droids in your CI/CD and CLI workflows
Droids in the war room (Slack/Teams for incidents)
Droids in your backlog (issue-triggered flows from Jira, Linear, etc.)

For an enterprise demo, teams usually anchor the session around one or more of these objectives:

Increase engineering throughput: Delegating refactors, migrations, and code review to Droids.
Reduce MTTR and incident pain: Using Droids during on-call to triage logs, generate diagnostics, and propose fixes.
Standardize code quality: Automated reviews, test generation, and documentation across services and languages.
Prove governance and compliance: Validate strict permissions, audit logs, data isolation, and IP controls.
Measure ROI, not token usage: See Factory Analytics—PRs, commits, files touched, autonomy ratio, OpenTelemetry export.

Having 2–3 concrete goals ready will make the enterprise demo sharper and will speed up the quoting process.

2. Use the fastest path to schedule your Factory enterprise demo

There are two primary ways to schedule a Factory enterprise demo and begin the pricing conversation.

Option A: “Contact sales” for enterprise deployment

Use this path if you:

Have 20+ engineers, or multiple teams
Need SSO/SAML, SCIM, or private networking
Care about data residency, SOC 2/ISO 42001, or SIEM integration

How to do it:

Go to the Factory website:
Open https://factory.ai in your browser.
Click “Contact sales” or “Start building”:
Both routes can get you into the enterprise flow; “Contact sales” is ideal if you already know you need custom terms.
Fill out the enterprise form:
Typical details that help Factory size and scope your demo:
- Company name and size
- Number of engineers you expect to onboard
- Primary languages and frameworks (e.g., TypeScript, Java, Go, Python, React, Spring)
- Key surfaces you care about (IDE, browser, CLI/CI, Slack/Teams, project trackers)
- Security requirements (single-tenant VPC, audit logging, SSO/SAML, IP controls)
- Preferred timeline (pilot start, rollout target)
Suggest demo participants and time window:
In the notes field, mention:
- Who should join (e.g., VP Eng, platform lead, security, team leads)
- Time zones and desired week for the session

Once submitted, Factory’s enterprise team will respond to schedule a demo slot and start capturing any requirements that impact pricing (e.g., regions, seat count, isolation model).

Option B: Start with app access, then request an enterprise quote

Use this path if you:

Want to experience Droids quickly in your browser or editor
Plan a small pilot that may later expand to a full enterprise contract

How to do it:

Go to the Factory app: Visit:
https://app.factory.ai/?factory_landing_url=https%3A%2F%2Ffactory.ai%2F
Sign in and try Droids in the browser:
- Run initial tasks (e.g., “Summarize this repo,” “Propose tests for this service,” “Explain this incident”).
- Explore how Droids plan, call tools, and interact with your code.
Use in‑app or site contact to escalate to enterprise:
- Once you’ve validated fit for your workflows, reach out via “Contact sales” or your account manager.
- Reference your existing usage so the team can pull real data (tasks, repos, workflows) into the pricing conversation.

This approach lets you ground the enterprise demo and quote in actual tasks your engineers have already run through Factory.

3. What happens during a Factory enterprise demo

Factory’s enterprise demo is not a generic product walkthrough; it’s designed around delegated tasks and your control requirements.

Expect the session to cover:

a) Droids across your SDLC surfaces

You’ll see how Droids operate where your engineers already work:

In the IDE/terminal:
- Delegating refactors, test generation, and code reviews directly in VS Code/JetBrains/Vim.
- Using terminals for real scripts, migrations, and incident diagnostics.
In the browser (no setup):
- Reviewing code, summarizing repos, and generating PR-ready changes.
In CLI/CI pipelines:
- Scripting and parallelizing Droids for large migrations, maintenance, and automated reviews.
In Slack/Teams war rooms:
- Triage incidents, investigate logs, summarize noisy threads, and propose mitigations.
In your backlog:
- Triggering Droids from tickets to draft fixes, tests, and documentation tied back to issues.

This is where the “agent design over model hype” philosophy shows. Factory will walk through explicit planning, environment discovery, tool calls, and error recovery—how Droids actually finish tasks in real environments.

b) How Factory handles enterprise security and compliance

The demo will explicitly address:

Strict permissions enforcement:
Droids see only what a user can already access in source systems (repos, tickets, docs).
Single-tenant, sandboxed environments:
Option for a dedicated VPC so your workloads are isolated.
Audit logging and observability:
Configurable audit logs exportable to your SIEM, plus OpenTelemetry support for deeper tracing.
Encryption standards:
TLS 1.2+ in transit and AES‑256 at rest for customer data.
No training on your code by default:
Factory does not use your code as training data without prior written consent.

If your security team is present, this is the time to ask detailed questions and clarify which controls are mandatory for your org.

c) Connecting Droids to outcomes via Factory Analytics

Factory will usually preview Factory Analytics so leadership can see:

Files created/edited
Commits and pull requests influenced by Droids
Delegation metrics and autonomy ratio
Tool usage and coverage across teams
Export paths to existing observability (OpenTelemetry)

This is critical for justifying spend: you’re not buying API calls; you’re buying measurable engineering output and MTTR reductions.

4. Information you should prepare to get an accurate enterprise quote

A precise quote for your engineering org depends on a few core dimensions. Having this ready will cut days off the cycle.

a) Team and usage profile

Be clear on:

Number of engineers for initial rollout and full rollout
Distribution across teams (platform, product, SRE, data, security)
On‑call patterns (24/7 vs. regional coverage)
Expected intensity of use:
- Light (PR review + occasional refactors)
- Moderate (daily delegated tasks, incident support)
- Heavy (CI/CD integration, large migrations, org‑wide reviews)

b) Technical and integration scope

Primary languages and frameworks (e.g., Java/Go/.NET, React, Kubernetes)
SCM and tracker systems (GitHub/GitLab/Bitbucket, Jira/Linear/Clubhouse)
Communication tools (Slack, Microsoft Teams)
CI/CD stack (GitHub Actions, GitLab CI, Jenkins, CircleCI, custom)

This informs which integrations you’ll need Day 1 and which can be phased in later.

c) Security, networking, and compliance requirements

Examples that meaningfully affect enterprise pricing and setup:

Need for single-tenant VPC and private connectivity
Required regions for data residency
SSO/SAML and SCIM requirements
Mandatory log export to SIEM
Compliance expectations (SOC 2, GDPR/CCPA, ISO 42001 alignment)

d) Rollout plan and success metrics

To align pricing with value, Factory will typically ask:

What’s your ideal pilot duration and scope?
What KPIs matter most:
- MTTR reduction for incidents
- Faster PR cycle times
- Increased deployment frequency
- Fewer context switches
How you prefer to measure impact:
- Factory Analytics dashboards
- OpenTelemetry into your existing observability stack
- Internal engineering metrics

The stronger your success definition, the easier it is to shape a quote and plan that will pass internal review.

5. How the quoting process usually works

Factory’s enterprise quoting process is designed for multi‑stakeholder deals (CIO/CTO, VP Eng, platform, security, procurement).

You can expect a rhythm like this:

Discovery + Demo (Week 0):
- Capture requirements, show end‑to‑end Droids in your workflows.
- Clarify security, compliance, and integration needs.
Scoping (Week 0–1):
- Define seat ranges, environments (e.g., single-tenant VPC), priority integrations, and pilot vs. full rollout.
- Lock in which benchmarks or outcomes you’ll track.
Proposal & quote (Week 1+):
- Receive a structured proposal with:
  - Pricing aligned to seats, environment, and support level.
  - Deployment model and regions.
  - Included integrations and support (e.g., 24/7 enterprise support, dedicated account manager).
- Iterate with procurement, security, and legal as needed.
Pilot & expansion (post‑signature or pre‑enterprise):
- Some orgs start with a paid pilot or an initial department and expand based on Factory Analytics and outcome data.

Throughout, Factory’s enterprise team keeps the focus on concrete artifacts: PRs, commits, incident timelines, and analytics—not just demo wow factor.

6. How Factory supports enterprise buyers through the process

When you schedule a Factory enterprise demo and request a quote, you’re not just talking to sales; you’re pulling in:

Product and engineering for deep dives:
To align on agent behavior, tool schemas, and how Droids will operate in your editors, terminals, and CI.
Security and compliance specialists:
To translate your policies into concrete controls (VPC design, logging, encryption, SSO).
A dedicated account manager for ongoing support:
For many enterprises, this includes 24/7 support and custom integration help.

The goal is to make the transition from “we saw a demo” to “Droids are in our SDLC with guardrails and metrics” as short and predictable as possible.

7. Checklist: before you click “Contact sales” or “Start building”

To make your Factory enterprise demo and quote fast and useful, assemble this in advance:

Estimated number of engineers (pilot and full rollout)
Key languages/frameworks and repos you care about
Primary pain points (incident response, refactors, code review, migrations, etc.)
Required surfaces: IDE, browser, CLI/CI, Slack/Teams, trackers
Security/compliance needs (SSO, single-tenant VPC, SIEM export, region constraints)
Target timeline for pilot and production rollout
Stakeholders who should attend the demo (VP Eng, platform, SRE, security, procurement)

With this in hand, your first session will move quickly from “what is Factory?” to “how do we deploy Droids effectively in our organization and what will it cost?”

Next Step

If you’re ready to see Droids operating in your environment and want a clear enterprise quote for your engineering org, start here:

Get Started