The AI app builder for teams
Your whole team builds together. On your own network.
Grafty is the self-hosted AI app builder where engineers, PMs and analysts build internal apps in one shared workspace, then publish them on your own infrastructure. Your keys. Your models. Nothing leaves your network.
- 0 bytes of your data leave your network
- 0% markup on tokens
- Your OpenAI & Anthropic enterprise agreements
The problem
Everyone has AI. Everyone's building alone.
In December 2025, Microsoft rolled out AI coding agents across an entire division. Six months later, it cancelled them. Not because the tools failed: adopters merged 24% more pull requests. Because every engineer was building alone, and nobody could see the bill.
01
Fifty laptops, fifty localhosts.
Every engineer prompts in their own terminal. Nothing is shared, and most of it never ships.
02
Four teams, one dashboard, built four times.
Nobody can see what anyone else has built, so they build it again.
03
No meter, no ceiling.
$500–2,000 per engineer per month at Uber. Finance can't forecast it and IT can't govern it.
Collaboration
One prompt. The whole team.
Product, R&D and Finance work in the same Builder Chat. Everyone sees the plan, the build and each other's changes, and the agent builds one app instead of four.
- One shared thread per app: prompts, plan, build, test, all visible to the team
- Team notes: talk to teammates in the same thread; the AI doesn't read them
- Auto / Balanced model mode, governed by IT
Live preview
Point at it. Comment. Ship it.
Not everyone writes prompts. Click any element in the live preview to reference it in chat, or pin a comment on it, like Figma, but on a running app. Send to Builder turns the comment into a change, immediately.
- Select any element and reference it in a prompt
- Pinned comments with replies, Open/Resolved, team-only visibility
- Desktop, tablet and mobile previews, and every revision kept
App catalog
Your company already built that. Now you can find it.
Every app published in Grafty lands in one searchable catalog. Search before you build, open what exists, and join its build chat instead of starting a duplicate. Permissions decide who sees what: open apps are visible to everyone, restricted ones only to the people they're shared with.
- Search, filter (All / Can edit / Public) and sort every published app
- Restricted apps stay invisible to everyone else
- IT finally sees every internal app that's running
Your keys, your data
You signed an enterprise AI agreement. Your app builder should use it.
On cloud AI builders, your prompts and code go through their servers under their model contract. Grafty runs inside your network and calls your models with your keys: your OpenAI or Anthropic enterprise agreement, your Azure or Bedrock endpoint, or a model running on your own hardware. We never see your data.
- Your OpenAI and Anthropic enterprise agreements: the preferred setup
- Azure and Bedrock-style enterprise endpoints, or fully local models
- Air-gapped licence available: no outbound connection at all
Bring your own provider - or run fully local
- OpenAI
- Anthropic
- Google Gemini
- Mistral
- DeepSeek
- Moonshot Kimi
- Meta Llama
- xAI Grok
- Cohere
- Perplexity
- Qwen
- Hugging Face
- Groq
- Together AI
Cost control
Every app has a price tag. IT sets the limits.
Grafty shows what every app costs, across everyone who worked on it, down to input, output and cached tokens. IT decides which models are approved, which are manual only and which are blocked, and sets a maximum price Auto will never exceed. The biggest saving isn't a cheaper model. It's building once instead of four times.
- Live spend per app, all contributors combined
- Models: Approved, Manual only or Blocked
- Auto limits: maximum input and output price per 1M tokens
- Budgets per user, project and team, enforced before the call
- 0% markup: you pay providers directly
Markup on model usage
Budget scopes: user · project · team
Limits enforced before the API call
Example scenario.
MCP server
Build from any agent. Ship on your own network.
Your developers already live in Codex, Claude Code and Cursor. Grafty includes an MCP server, so any MCP client can work with your Grafty instance directly: pick up a teammate's comment, fix it, reply on the thread and publish, without leaving the editor. Sign-in follows the MCP authorization spec (2025-11-25).
- Read and reply to team comments, with the element each comment points at
- Create apps and request changes, then wait on or cancel the build
- Find apps, read their files and history, and use Team chat
- Check GitHub sync status and resync
- Preview first, then publish: Grafty returns a preview and a confirmation code, and nothing goes live until the agent sends that code back
Works with
- Codex
- Claude Code
- Claude custom connectors
- Gemini CLI
- VS Code
- Cursor
- Devin
- Pi
- any MCP client
Security & trust
Built for the security review you're about to run.
Architecture overview, threat model, SBOM, and DPA available on request. Built to pass the security review, not work around it.
Single-tenant, customer-operated
Each customer runs their own Grafty instance on their Linux infrastructure. There is no shared SaaS plane.
Isolated runtime per app
Every generated app runs in its own isolated environment with resource quotas - isolation by default.
Encryption everywhere
All inter-service and ingress traffic over TLS. Provider keys and integration tokens encrypted on disk on the instance.
Immutable audit
Append-only audit events for privileged actions, scoped by role and exportable for SIEM ingestion.
SSO and RBAC
Single sign-on on the Enterprise tier, with instance admin, developer and viewer roles and per-app access controls.
Your licence, your choice
Two licence options: fully air-gapped, or a licence-status ping that never carries customer data.
Where data lives
Inside your network boundary:
- Builder UI
- Source code
- Git history
- Previews
- App data
- Audit logs
- Integration credentials
We do not receive, store, or process your prompts, code, or runtime data.
The comparison
Why teams pick Grafty over cloud AI builders
Pricing
One platform. Three tiers. No surprises.
Grafty does not mark up model usage. You connect your own providers and pay them directly - the platform enforces usage limits before calls are made, so there are no surprise invoices.
Pilot
POC on a single server. Prove the model with your security team.
Contact us
- 1 instance
- Up to 5 users
- Community support
- Per-user token budgets
- Standard legal docs
Team
Production install for platform and internal-tools teams.
Contact us
- Production install
- Unlimited users (fair use)
- Shared Builder Chat with comments
- App catalog
- Usage dashboards by user & project
- Per-team monthly token caps
- Email support + SLA options
- Security questionnaire help
Enterprise
Regulated, air-gapped, or multi-site rollouts.
Custom
- Air-gap + local LLM patterns
- SSO
- Shared Builder Chat with comments
- App catalog
- Advanced governance & audit exports
- Dedicated support
- DPA, SLA, custom terms
- Multi-instance bundles
Get started
See your team build together, on your own network.
Grafty deploys on a Linux host in minutes. Talk to our team about pilot licensing, security review, and rollout planning.
- Pilot deployments up in an afternoon
- Security review pack on request
- No model markup - bring your own keys
- Limits enforced before the call