Fractera — Project Knowledge Base

Fractera is a source-available (Open Code) platform that turns a bare Ubuntu VPS into a complete, self-hosted, AI-native development environment in about 10 minutes — with one click or a short chat.

On your own server you get: five AI coding platforms (Claude Code, Codex, Gemini CLI, Qwen Code, Kimi Code), the Hermes orchestrator, LightRAG persistent memory, authentication, a database, and file storage — all pre-wired. No Clerk, no Supabase, no Vercel. One bill (your VPS), one place, full ownership of code and data.

You can install the full stack, or pick only the components you need — down to a plain server with a database and sign-in and no AI at all.

1. You provide a server (IP + root password) — or buy a VPS first (see "VPS & pricing").
2. You choose what to install — the full stack or only the components you need.
3. Fractera's automated setup service configures everything on your server for you: it installs the tools you selected and sets up the database, authentication, file storage, and web routing, then brings all services online. You never run any commands yourself.
4. In ~8–14 minutes the workspace is live. You get email notifications when setup starts and when it finishes.

The result is IP-first: when it finishes, your workspace is live on plain HTTP at http://<your-IP>:3002 — that is the Admin workspace where you start coding. Attaching your own domain with HTTPS is an optional later step you do yourself, inside the workspace (Admin → Personal Domain).

Three ways to start: the one-click form on the website, a partner/embed widget, or by chatting with an AI agent through the Fractera MCP connector.

Traditional self-hosting is plagued by DevOps friction — hours spent configuring an Nginx reverse proxy, wrestling with Let's Encrypt SSL renewals, securing the database, and wiring up authentication gates. Fractera removes that barrier.

You provide nothing more than your bare Ubuntu server credentials, and an automated orchestration layer configures the entire infrastructure from scratch — with no terminal commands on your end.

Better still, you don't even need to open a browser: you can trigger the whole deployment — and check its status on demand — programmatically through our custom MCP (Model Context Protocol) connector, right inside your AI coding environment. It's the simplicity of Vercel, brought natively to your own private hardware.

You decide what gets installed (a lighter, cheaper server). Selectable components:

• Claude Code — Anthropic coding agent
• Codex — OpenAI Codex CLI
• Gemini CLI — Google coding agent
• Qwen Code — Alibaba Qwen coding agent
• Kimi Code — Moonshot Kimi coding agent
• Memory — LightRAG vector knowledge base
• Brain — Hermes orchestration agent

Always installed (the core, never optional): the web app, authentication, database, object/file storage, the admin panel, and the admin panel's own system terminal. Unchecking every box above gives you a plain server with a database and sign-in — no AI.

You are never locked in: any recommended or custom tool can be installed later from the terminal built into your admin panel.

Claude Code, Codex, Gemini CLI, Qwen Code, and Kimi Code — all preconfigured on your server, each driven through a WebSocket bridge.

Key principle: they run on your existing subscriptions, not pay-per-token API keys. Sign in to each platform once (standard browser-based login, like a local CLI). No API keys to manage, no per-token billing surprises. You can switch platforms mid-task without losing your project context — LightRAG keeps the thread.

"Bridge online" means the process is alive and the WebSocket handshake works; logging into each platform's subscription is a separate one-time step after that.

Two separate billing models — do not conflate them:

• The five coding platforms (Claude Code, Codex, Gemini CLI, Qwen Code, Kimi Code) run on YOUR existing subscriptions. You sign in once with your normal account (standard browser login, like a local CLI) — no API keys, no per-token billing. This is where the heavy AI work happens, and it costs you nothing beyond the subscription you already pay the AI vendor.
• Brain (Hermes) and Memory (LightRAG) use one small OpenAI API key — the cheap gpt-5-mini (about 1 cent per hour) is plenty to start, or a Codex subscription if your usage is heavy. This is the only per-token piece, and it is tiny and auxiliary.

So: a Claude Code user pays through their Claude subscription, not per token. Per-token API spend, if any, is limited to the small Brain/Memory model — not the coding platforms.

Track Brain and Memory spend separately (optional). Brain and Memory keep their OpenAI keys in two independent places, so you can meter each one on its own. Create two separate API keys in OpenAI and paste one into the Memory key field and the other into the Brain key field (in the OpenAI settings). One key works fine for both — but two keys let you watch each line item independently in the Usage dashboard at platform.openai.com.

Memory is a persistent vector knowledge base (LightRAG by HKUDS) shared across all your coding platforms. Feed it your codebase, documents, and architectural decisions; the agents query it to stay grounded in your context.

Why it matters: without persistent memory, every AI session starts from scratch — tokens spent re-explaining "where is the navbar?" are tokens not spent on your feature. Memory compounds with every iteration, so tasks that take 10–20 back-and-forth messages in a vanilla chat often resolve in 2–3. It does not auto-learn — it stores only what agents explicitly push. Activating it needs an OpenAI API key (used economically — the embedding model is among the cheapest), set in Admin → Memory settings.

Brain is the Hermes Agent (by Nous Research) deployed and configured on your VPS — the thinking centre of the workspace. It coordinates the connected AI subscriptions through shared context and can run autonomous, multi-step pipelines where each loop refines the next ("let Claude do this and Codex do that" — in parallel).

You talk to Brain through its built-in web chat, which opens automatically in the admin panel and is the primary way you use the system — just add a model to start. Talking to Brain from your phone via a Telegram bot is an optional secondary channel. (See "Hermes Web Chat — the main way you talk to Brain".)

Authentication is not a single login screen bolted on — it is a layer-wide gate. A dedicated Auth service is the only component that issues the session, and every other service and page checks that session before serving anything.

• One session authority. The Auth service (NextAuth) is the sole writer of the session cookie. Providers: email + password (bcrypt) and Google OAuth / magic link. Client code never calls the auth service directly — pages ask a single /api/me endpoint, which resolves the current session.
• Per-service gate. The user-facing app and the admin workspace each run a request gate ("proxy") that runs BEFORE any page or API handler: no valid session → redirect or 401. So hitting any of these services without a session gets you nothing.
• Gate for the non-web services too. The database/storage service, Memory, and Brain don't serve web pages, so in secure mode the web server (Nginx) enforces an auth check (auth_request) on each of their subdomains — every authenticated host requires a valid session, closing any side door.
• Roles. Each user has roles (default user). user can use the app; admin has full access to the admin workspace and the coding platforms. The first person to register on a fresh server becomes the admin; admins can promote others.
• Modes. In open/IP onboarding mode the gates are intentionally relaxed for friction-free first access; once you attach a domain (secure mode) the cookie becomes Secure, scoped to your domain, and every gate strictly enforces.

Both the database and the file/object storage run on your own server as part of the layer — there is no external Supabase, no S3 bill.

• Database. A single SQLite database file (app.db) holds the application data. The schema is defined in ONE place and applied automatically at startup, so the local and remote paths always agree — there are no migration files to juggle and no "run migration" button. A dedicated data service owns the database and exposes it over an authenticated HTTP API; the app talks to it through that service.
• Object / file storage. The same data service stores media and files on the server's local disk and handles image work (icon generation, thumbnails, crops). Uploaded media is served back through the app, never from a third-party bucket.
• Ownership. Because both live on your VPS, your records and files never leave your server. Back them up (export) and restore (import) whenever you like; pausing the project never deletes your data.

Each of the five coding platforms runs on your server behind its own WebSocket bridge — a live process you can drive interactively. Brain (Hermes) sits above them as the orchestrator.

• Delegation over MCP. Brain reaches each coding agent through a per-platform MCP delegation tool (each platform gets its own MCP endpoint on its own port). Through these tools Brain can hand a task to Claude Code, Codex, Gemini CLI, Qwen, or Kimi — individually or several at once.
• Parallel, multi-step work. Because delegation is tool-based, Brain can run autonomous pipelines: split a job ("let Claude do this part and Codex do that part"), run them in parallel, collect results, and decide the next step — each loop refining the next.
• Shared context. The agents are not isolated silos: they share project context (and Memory, below), so switching an in-flight task from one agent to another does not lose the thread.
• You talk to Brain, Brain talks to the agents. There is no separate chat UI for each agent in normal use — you direct Brain through its built-in web chat in the admin panel (or, optionally, a Telegram bot) and Brain coordinates the rest.

Inside the admin panel there is a Deployments table that logs every development deployment — the running journal of *how your project gets built*. It deliberately mirrors the familiar Vercel deployments list, then adds the columns a generic cloud host cannot have.

A standard cloud platform shows you *that* a deploy happened: commit, status, branch, duration. Fractera shows you the whole story of the change:

• Result — a 1–3 star quality rating (first column). Hermes records each row with a default of three stars; you can change the rating at any time by clicking the stars and saving — your honest feedback on how good the work was.
• Platform — which AI coding agent actually did the work (Claude Code, Codex, Gemini, Qwen, Kimi).
• Model — the exact model used.
• Tokens — the real token cost of producing the change, captured straight from the agent's run (not estimated).
• Page — the URL where you review the change (last column), alongside a Created timestamp and the familiar commit / status / duration / branch / author cells. Every column sorts, and you can split deployments by project (a projects list you manage) and filter the table by one or more of them.

Why this is the loop. Hermes takes a decision, delegates the coding to one or more agents, deploys, then records the result and hands you the page link to review. You rate it. Over time the table becomes a feedback record of agent-driven development — which agent and model produce the best results for your project, at what token cost — something a deploy log alone can never tell you. It is the visible heart of Fractera's "product loop": build, deploy, review, rate, improve. See the whole agent-driven cycle visualized in the Fractera development loop.

Memory (LightRAG) is the shared accumulator of the whole layer — one vector knowledge base that every agent reads from and writes to, so context compounds instead of resetting each session.

• Shared accumulator. There is a single Memory for the server. Whatever any agent stores there — your codebase, documents, architectural decisions, solved problems — becomes available to every other agent. Knowledge accrues over time rather than living in one chat's history.
• How information gets in. Memory does not auto-learn. Agents (and you) push content into it explicitly through an ingest endpoint; each write is tagged with the identity of the agent that made it. This keeps the store curated, not noisy.
• How Brain and each agent use it. When working a task, Brain and the coding agents query Memory to ground their answer in your accumulated context before acting — so an agent starts a session already knowing your project instead of asking "where is the navbar?". Brain in particular leans on Memory to coordinate: it pulls shared context, then delegates with that context in hand.
• Practical effect. Tasks that take 10–20 back-and-forth messages in a vanilla chat often resolve in 2–3, because the model arrives already grounded. Activating Memory requires an OpenAI API key (used economically — the embedding model is among the cheapest), set in the admin panel.

IP / insecure mode (the default right after deploy): the workspace is reachable at http://<IP>:port over plain HTTP, with open onboarding. This gets you into your workspace in seconds, with no DNS or certificate wait. Your browser will show a "Not secure" warning — that is normal until you attach a domain.

Secure mode (after you attach your own domain): everything runs on https://<your-domain> with a free Let's Encrypt certificate (auto-renewed), strict role-based sign-in, and a host firewall that closes all service ports except 80/443. For regions or compliance rules where Let's Encrypt is unavailable, you can upload your own certificate.

You switch from IP to Secure yourself, inside the workspace (Admin → Personal Domain), whenever you want — and you can switch back.

A fresh deploy is IP/insecure by default. Moving to secure mode is a guided wizard in Admin → Personal Domain, run entirely from your own server:

1. DNS. Point your domain's A-records — the apex plus the service subdomains (www, auth, admin, data, hermes, lightrag, and chat for the built-in web chat) — at the server IP. The wizard verifies they resolve.
2. Certificate. The admin app runs certbot on the server to issue a single Let's Encrypt certificate covering all those hostnames. Alternatively you upload your own certificate — a first-class path for regions where Let's Encrypt is unavailable or where compliance requires specific (e.g. national / GOST) certs.
3. Activate. The workspace switches every service into secure mode at once: the mode flag flips in all services, the session cookie becomes Secure and scoped to your domain, Nginx is rewritten for HTTPS, and a host firewall closes every inbound port except 80/443. A safety watch probes the new domain and auto-rolls-back to the previous settings if it doesn't come up — so a mistake degrades gracefully instead of bricking the server.

How the coding-platform bridges connect. In IP mode the browser talks to each platform's bridge directly over ws://<host>:<port>. In secure mode they move to path-based wss under the cert-covered admin host — wss://admin.<domain>/ws/... — so the interactive terminals keep working over TLS with no mixed-content blocking.

Reading the Step 3 health-check (200 / 307 / 404 are all fine). The final check marks a host healthy when three things hold: DNS resolves to your server, the TLS certificate is valid (strict verification passes), and the service answers with any normal code in the 200–499 range (not a timeout, not a 5xx). The exact code is just informational — it tells you what the service returns at its root /:

• 200 — the service serves a page at / (apex, www, admin, hermes, chat).
• 307 — the service redirects at / (auth → the sign-in form; lightrag → its own UI). A normal redirect.
• 404 — the service has no page at / (data — a media/DB API that legitimately serves nothing at the root).

Only a real failure blocks the switch: DNS not resolving, an invalid certificate, a timeout, or a 5xx. If none of those occur, all hosts are green even with a mix of 200/307/404.

Reversible. A "switch back to IP / demo mode" option restores the previous configuration and reopens the service ports. Certificates auto-renew (~every 60 days); if a certificate nears expiry an early warning email is sent.

Everything your application needs — authentication, database, file storage, AI memory — lives on a server you own. No third party has access to your data. No dependency on someone else's uptime, pricing changes, or terms.

This is the cloud-exit promise: no Clerk subscription, no Supabase invoice, no Vercel bill that scales with traffic; one server, one bill. If you pause your business, your data does not disappear — back it up and restore when ready. Your application code lives on GitHub, so recovery is always possible, and the built-in AI assistants can help rebuild even when dependencies have aged. It also helps you meet regulatory or internal-policy requirements and avoid surprise bills.

The admin workspace — also called Bridges — is the control panel that runs on your server. It is where you actually drive everything, and it requires the admin role (the first person to register on a fresh server). By default it gives you:

• A carousel of your installed coding platforms. Click one to open its live interactive terminal; an always-present system terminal is the last card (see "The system terminal").
• Brain and Memory canvases (if those components are installed) — open the Hermes and LightRAG interfaces inline.
• Settings menu: Users (accounts and roles), Upload media, Database browser (view and edit tables directly), Environment variables, Personal Domain (the IP → secure wizard), Hermes / Memory settings (API keys), Export / Import data (a backup ZIP of database + storage), and Help.
• Footer actions: Deploy (rebuild the open app layer after changes), GitHub connect with one-click Pull / Push, Info (README), links to Skills and Product Loop, and the current build version.

Everything an agent or you build lives behind this panel, and every part of it is gated by authentication (see "How authentication blankets the whole layer").

The admin panel includes a system terminal — a plain project-level shell on the server, always present as the last card in the carousel. Unlike the AI platforms it can never be disabled, because it is part of the core.

Use it to install extra tooling, run one-off commands, link your Telegram bot to Brain, install your own copy of a coding agent, or anything else the server level needs. It opens at the project root where the services live.

Fractera is free. There are no plans and no tiers — the platform is always free to use. The only money involved is the VPS you run it on (paid to your hosting provider, never to Fractera) and optional, voluntary sponsorship ($1 / $5 / $20 — see "Sponsorship & Fractera Pro").

For full AI-coding workloads the recommended minimum is 4–6 cores and 6–8 GB RAM; storage depends on your project (75 GB is a solid baseline). Once active AI development wraps up, you can downgrade to ~2 cores / 4 GB RAM — often just a couple of euros per month. A plain server with no AI needs even less.

You bring your own VPS from any provider.

• Vibe-coders and solo founders who want a production stack (auth, DB, storage, AI) without wiring ten cloud services together.
• Experienced developers who want to offload cloud-resource management and DevOps — deploy a plain server, sync it with a local IDE (e.g. VS Code) over GitHub, and treat their own VPS as a self-hosted alternative to Vercel.
• Teams needing data sovereignty — keep user data, auth, and database on infrastructure they control, to meet regulatory or internal-policy requirements.
• Builders bringing an existing project — connect a GitHub repo and continue AI-assisted development on the server.
• People who want autonomous AI workflows — let Hermes coordinate multiple agents on multi-step tasks.

The same server can be used purely as a self-hosted backend (database + object storage + optional auth) with no AI at all.

Fractera is not just a theoretical framework — it is a deployment engine for practical, custom automation. Because the architecture enforces a strict split between the public-facing application (open layer) and the authenticated admin panel (guarded layer), builders use it to solve asymmetric operational problems with minimal token spend. Here is what real users have already built and deployed on Fractera.

1. The Collaborative Content Engine (private internal workspace)

• The problem: a high-traffic blogger needed a unified workspace where a distributed team of editors could collaborate on content planning, draft preparation, and asset management — without exposing the system to the public.
• The Fractera solution: deployed entirely in secure, authenticated mode. The team uses the built-in SQLite database and file storage to manage the publishing pipeline. Editors work in an isolated environment, using Fractera's cross-platform AI routing to brainstorm structures and refine texts collaboratively — turning a standard VPS into a private corporate command center.

2. The Local Service Dispatcher & Smart Kanban (automated lead routing)

• The problem: a custom-furniture salon manager needed to automate dispatching for kitchen and wardrobe measurement requests — ingesting incoming emails from the marketing site and dynamically routing them to field engineers by geographic proximity to cut city-travel costs.
• The Fractera solution: a background service fetches inbound emails via API and turns them into structured data. Fractera's local database acts as the state machine, rendering a secure, internal-only Kanban board. It stores field-tech availability and locations, letting authenticated staff orchestrate logistics privately — without a single byte of customer data leaking to third-party cloud platforms.

3. Adaptive AI Tutor (hybrid public/private EdTech)

• The problem: a parent wanted a hyper-personalized programming course for her child that adapts daily based on real performance, controlled securely via mobile commands.
• The Fractera solution: a hybrid public/private structure. The child uses an unauthenticated, lightweight public page to complete interactive daily coding challenges; results are piped securely to the backend database. The parent uses a private dashboard and a dedicated Telegram bot connected to the Hermes orchestrator. Based on the child's performance metrics, the parent issues a voice command, prompting the AI to instantly restructure the next day's lesson database.

4. Viral Trend Scraper & Autonomous Blog Loop (public passive-traffic generator)

• The problem: a content creator wanted to monitor trending topics across competitive Telegram channels, enrich those signals with live web data, and autonomously publish optimized long-form articles to a public blog and external resources to capture maximum traffic.
• The Fractera solution: the server acts as an autonomous data agent. A scheduled script monitors specified Telegram channels, feeds hot topics to the Hermes orchestrator, expands them with real-time search (e.g. the Exa API), and publishes the enriched posts via external APIs. The public site runs as a static, blazing-fast SEO blog with no user registration. Meanwhile traffic metrics are piped back to the creator's Telegram bot, so they can track performance and iteratively optimize publishing schedules.

5. Dynamic School Timetable (collaborative scheduling)

• The problem: building a school timetable is notoriously hard and never static. The standard schedule constantly needs exceptions — one teacher requests a day off, another is out sick, someone has to take overtime or cover substitute classes, someone comes in on a day off for school-wide events. Reconciling everyone's constraints by hand is painful.
• The Fractera solution: the school started by using the agent to generate surveys, sending links through their existing chat to private pages where each teacher's availability and preferences are collected. The agent forms a baseline timetable; each teacher has a private page to request changes; the system reads every teacher's input and the schedule dynamically re-builds until it is approved in a way that suits the maximum number of teachers. When something unplanned happens — a teacher falls ill — the model can even suggest which teachers would be the best fit to offer the substitute lessons to.

Fractera's partners are bloggers and YouTube creators who recommend Fractera to their audience. Instead of a plain referral link — which would send their readers to the general landing page (aimed at a different audience) and leak traffic — each partner gets two conversion-focused surfaces:

• Partner page — a personal mirror of the Fractera landing at https://www.fractera.ai/partner/<lang>/<slug>, trimmed to just the order section (enter server details, pick a provider). It also satisfies what hosting providers require for affiliate approval: a real URL where the affiliate link lives.
• Widget — an <iframe> the partner embeds on their own site or blog; it renders the same single order section, so the creator can write about any topic and offer server signup right inside their own page.

Partners connect their own affiliate links in two categories that match the two deploy phases: a VPS provider (the IP-first server phase) and a domain registrar (the later secure custom-domain phase). Only providers on Fractera's trusted whitelist appear automatically — this protects readers from links to fake resources. To get a new provider added to the whitelist (for servers or for domains), a partner contacts the Fractera team for review.

Becoming a partner is one click (auto-approved) from the Partners page; the cabinet then lets the partner manage their server/domain affiliate links, fill in the page footer details, and copy the widget snippet.

Production AI development happens entirely in your browser, from the first second — no VS Code, no local environment to configure, no database to spin up, no deployment pipeline to debug. You open a tab and the server is already live, the domain registered, the database running, and the coding platforms wait for your first command.

• Voice commands. Issue coding commands and navigate content hands-free via microphone; agents respond to natural voice input in real time.
• Instant production. One click deploys your changes live — no CI pipeline, no hosting config.
• Any device. All computation runs on the VPS, so a laptop, tablet, or phone is enough.

This is what lets anyone with an idea — not only engineers — build, ship, and scale a real product without leaving the browser.

This is your software on your servers. Fractera helps install it — and nothing more.

• Change your password after install. Immediately after installation completes, change the password for access to your server.
• No access, no control. Fractera does not gain control over your code, and we have no access to your servers. There is no backdoor — the deployed product cannot push to our repositories (verified by a security audit).
• Always recoverable, always portable. Your code lives on GitHub and your data on your VPS; you can inspect it, back it up, export it, or walk away at any time. Nothing locks you in.

Direct answers to the questions technical reviewers and security teams ask most about the Fractera MCP connector.

Does Fractera store my server's root password?

No. The root password is used only transiently, inside the single deployment SSH session, to install the workspace — it is never written to our database. A placeholder is stored in its place, and the dashboard shows a "password is never stored" indicator. For retry_deploy you simply provide the password again. We strongly recommend changing the server password immediately after installation.

Can Fractera access or control my server after deployment?

No. Because we do not retain the password — and we recommend rotating it after install — Fractera holds no standing administrative access to the servers it deploys. There is no backdoor: a deployed workspace cannot push to Fractera's own repositories (verified by a security audit). You can have your own AI agent audit every installed file against the public source at https://github.com/Fractera/Agent-Engineering-Infrastructure, before and after deployment.

What data does the connector collect and keep?

Only what is needed to deliver the service: your email (to send install / completion / recovery notifications) and your server IP (to provide follow-up value such as TLS-certificate-expiry reminders and health notices), plus your component selection. The root password is NOT kept (see above). Your application data — database records, files, user accounts — never leaves your own server.

Does the connector require authentication?

No. It is an open connector — no API key, OAuth, or account is required to connect. Authorization for the destructive action is implicit: a deploy only ever touches the specific server whose IP and credentials the user explicitly provides in that conversation.

What does each tool do, and which are destructive?

• register_and_deploy — destructive: wipes and installs the workspace on the server you provide.
• retry_deploy — destructive: re-wipes and reinstalls on the same server after a failed attempt.
• check_status — read-only: returns deployment progress.
• get_subdomain — read-only: returns the finished workspace address.
• get_vps_recommendation — read-only: suggests a VPS provider.
• get_project_info — read-only: answers questions about the project.

All tools carry the proper readOnlyHint / destructiveHint annotations. The read-only tools are completely safe to test without any server.

Does it enable cross-service automation, or move money?

No to both. The connector does not chain or relay between third-party services — it acts only on a single target: the user's own VPS. It never transfers money, cryptocurrency, or executes financial transactions; the deployment itself is always free.

Is the connection encrypted?

Yes. The connector is served over HTTPS/TLS using the streamable-http transport, with CORS configured for clean client handshakes. The SSH session to your server during deployment is likewise encrypted.

Included for everyone:

• Hermes AI agents with self-learning memory
• Voice AI commands
• Built-in auth: Google OAuth, magic-link email, credentials, role management
• Database (SQLite, WAL mode) + object/file storage + media service
• One-click backups & restore (snapshot and re-upload to restore or clone)
• GitHub sync — push, pull, and deploy from the admin panel in one click
• All five coding platforms preconfigured; LightRAG memory initialized on first start
• Skills marketplace access

Advanced — Fractera Pro ($20 sponsors): production SEO, PWA and multi-language routing; element highlighting (click any UI element to capture its exact id — fewer tokens); up to 11 parallel routing slots with static SEO; ready-made page sections that cut token spend many times over. See "Fractera Pro".

In early 2026 the largest untapped AI value was described as sitting inside businesses that have neither a website nor an API — the work currently handed to outsourcers (customer service, operations) that AI could do directly, framed as close to a trillion-dollar opportunity.

Fractera is built to let a single founder or a small team reach that opportunity: stand up real, owned software infrastructure fast, then let AI do both the building and the operating. The point is not "another dev tool" — it is letting anyone with an idea ship and run a real product, owning the whole stack.

Separate from the on-VPS "Memory" and "Brain" described above, Fractera offers a B2B AI Company Brain: a physical Apple Silicon appliance (Mac mini or Mac Studio) placed in your office and personally configured by the Fractera founder.

It combines a private LightRAG knowledge graph — ingesting meetings, documents, voice memos, emails and chat history into structured corporate memory — with a Hermes agent that acts on it and returns finished work as clean links (a document, a deck, a site), briefed by voice from Telegram. It runs 24/7 on your desk (~30W) and nothing leaves the building. Pricing is by agreement (each engagement scoped to the business); capacity is strictly limited. First step is a founder consultation — [email protected].

Country-specific note for Russia. The public side of your project is 100% under Russian jurisdiction: server, user data, domain and certificate stay in the Russian Federation.

• User data in Russia (152-FZ). Database, file storage and authentication run on your server in Russia; the infrastructure lets you meet the 152-FZ requirement to store citizens' personal data in-country.
• Server in Russia. Deploy with a Russian provider (e.g. Timeweb Cloud); the whole production perimeter stays under Russian jurisdiction, with no foreign clouds in the data path.
• Domain & certificate by Russian law. A .ru domain at a Russian registrar (e.g. reg.ru) and TLS are set up automatically; national / GOST certificates fit the sovereign-infrastructure logic (you can upload your own certificate).
• Development is the developer's free choice. You write code with any AI assistant and may work from abroad — that is the private side, outside the regulated personal-data perimeter. For those who want full sovereignty, Chinese models Qwen and Kimi are available without restrictions.

Responsibility boundary (honest): the infrastructure is sovereign; responsibility for processing specific personal data in production rests with the developer. Fractera "lets you comply", it is not a certification.

The workspace that runs on your server is open and available as Open Code on GitHub — every layer of it: the web app, authentication, database/storage service, the coding-platform bridges, the memory (LightRAG) and orchestrator (Hermes) integrations. You own it and can inspect, extend, or self-host it entirely.

Provisioning, billing, and the automated setup/delivery are handled by an external Fractera service that we operate. It is what puts the Open Code workspace onto your server and manages your account — you interact with its results (the deploy, the dashboard, the emails), not its internals.

So: the product on your server = open. The service that delivers and bills it = operated by Fractera. Your code and data always stay on your server.

By default your server ships with a minimal auth setup. There is no limit on extending it: using the in-VPS AI agents you can ask to add new auth providers or new roles freely.

One strong recommendation: do this while in insecure (IP) mode. Insecure mode does not restrict access to the admin panel, so if a change accidentally breaks authentication you can still get back in and keep working. In secure mode, breaking auth can lock you out of the project entirely. So experiment with auth in insecure mode, confirm it works, and only then switch to secure mode.

You can add tools yourself through the system terminal — OpenClaw, OpenCode, or any other tool. The AI model has enough patterns in the codebase to copy how an existing platform works and add a new window plus a carousel button for it — just ask it directly to do this.

More broadly, you may change the architecture, add skills, or optimize the project however you see fit. This is not only allowed — it is recommended. That is exactly why every part of the Agentic Engineering Infrastructure is fully Open Code (source-available).

If you want to remove the "Powered by Fractera" line that appears on your public pages: you will most likely not find it in the application code, and trying to hunt it down may break your project — it is applied at the web-server layer, not in app code.

If its presence bothers you, the simplest safe trick is to overlay your own container on top of it to make it invisible. The recommended path, though: become a sponsor (the $5 tier removes it) and just ask — we'll tell you how to do it properly.

Two future products (planned, not fully built yet):

• Skills — packaged, reusable AI workflows. Package the workflows you have solved, sell them, share them free, or buy battle-tested recipes from other builders.
• Product Loop — the digitized end-to-end entrepreneurial journey (company registration → traffic → unit economics → scaling) as conditional, branching decision logic another founder can buy. Not a step-by-step manual but a living knowledge base of the decisions that worked.

Pricing is set by the users who create the skills or digitize their business — Fractera does not set prices. The project acts only as the observer/host: it provides the server capacity these services run on and takes a 20% commission.

Fractera's partners are bloggers and YouTube creators who recommend Fractera to their audience. Instead of a plain referral link — which would send their readers to the general landing page (aimed at a different audience) and leak traffic — each partner gets two conversion-focused surfaces:

• Partner page — a personal mirror of the Fractera landing at https://www.fractera.ai/partner/<lang>/<slug>, trimmed to just the order section (enter server details, pick a provider). It also satisfies what hosting providers require for affiliate approval: a real URL where the affiliate link lives.
• Widget — an <iframe> the partner embeds on their own site or blog; it renders the same single order section, so the creator can write about any topic and offer server signup right inside their own page.

Partners connect their own affiliate links in two categories that match the two deploy phases: a VPS provider (the IP-first server phase) and a domain registrar (the later secure custom-domain phase). Only providers on Fractera's trusted whitelist appear automatically — this protects readers from links to fake resources. To get a new provider added to the whitelist (for servers or for domains), a partner contacts the Fractera team for review.

Becoming a partner is one click (auto-approved) from the Partners page; the cabinet then lets the partner manage their server/domain affiliate links, fill in the page footer details, and copy the widget snippet.

Separate from the affiliate Partner Program, Fractera is looking for regional partners who represent Fractera in their region on equal terms — promoting the business and receiving and fulfilling orders to install Fractera and the AI Company Brain locally.

• Business requirements: a registered legal entity operating 3+ years; a significant audience of partners or subscribers; strong SEO and external-link skills; business-development skills.
• What we offer: a page for your region carrying your own VPS + domain referral links; referral rewards split 30 / 70 (partner keeps 70%); official Fractera reseller status in your region.
• Partner responsibilities: promote your regional page in search by driving traffic via your own publications, pages and mailings — the more visitors, the more referral reward from VPS and domain sales.
• What a "region" is: either a whole country (when it is effectively one state/region) or a state/region within a country — so one country can have several regional representatives.
• How to apply: email [email protected] with the subject "Regional representation application". Full page: /en/regional-partners (or /ru/regional-partners).

Fractera charges nothing — support is entirely voluntary. There are exactly three sponsorship amounts: $1, $5, or $20 per month. No other amounts are ever charged, and there are no hidden plans.

Each tier unlocks perks:

• $1 — access to the private sponsor community (architecture details, debugging help, faster fixes).
• $5 — also removes the "Powered by Fractera" branding from your site.
• $20 — Fractera Pro: the full, densest set of advanced pre-built capabilities (see "Fractera Pro"), plus direct access to the founder.

Even $1/month makes a real difference and unlocks the private channel.

Fractera Pro is an advanced architecture built on deep, hard-won Next.js 16 expertise — it unlocks the full power of the framework.

Advanced capabilities like parallel routing, search-engine optimization, and static generation — with a focus on doing the work with minimal calls to the server — are exactly the things AI tools most often get wrong or wire up with serious mistakes. The reason is simple: there are almost no correct examples of these patterns on the internet, so a model has nothing reliable to imitate. The right configuration is found only through an enormous amount of testing to discover the patterns that actually work.

Pro gives you the densest possible saturation of these advanced features — and you don't spend tokens building them. They arrive as pre-configured page templates and tools, ready to use. Fractera Pro is available to $20 sponsors.

On your VPS the product runs as seven cooperating services (kept alive by a process manager) behind one web server (Nginx):

• Shell app — the main user-facing application and iframe host; this is the open layer where your product is built.
• Auth — the only service that issues the login session.
• Admin / Bridges — the control panel (carousel, settings, domain wizard, deploy) and the Memory (RAG) proxy.
• Bridges — the WebSocket bridges to the five coding platforms, and the always-on system terminal.
• Data — the SQLite database plus media / file storage.
• Memory — the LightRAG vector knowledge base.
• Brain — the Hermes orchestration agent.

Only ports 22/80/443 are public. The service ports are reached through Nginx in secure mode, or directly on the IP during onboarding. Nothing else is needed — no external Postgres/MySQL, no S3/MinIO, no Docker; the database is a file and storage is local disk, all on your server.

The product exists so AI agents can build YOUR app, so the layers have different access rules:

• Open layer (the app): where the in-VPS coding agents work freely — this is your product.
• Guarded layers (auth, data, memory, bridges): soft-protected from accidental agent edits; advanced users can still extend them — add an auth provider, a new data strategy, or tune the agent ↔ memory wiring.

The whole product on your server is Open Code (source-available). A security audit confirmed that a deployed server cannot push to Fractera's own repositories — your instance is isolated and yours.

In secure mode access is protected by two independent layers:

• Per-process authentication. The mode flag is per-service; in secure mode every service enforces login. The session cookie is Secure and scoped to your domain, so it is never sent to a bare-IP address — you cannot be logged in over the plain-IP path.
• Host firewall. Secure mode closes every inbound port except 80/443, so the service ports (database, Memory, Brain, etc.) are unreachable from the internet. Nginx on 443 becomes the only entrance, while the local reverse proxy to each service keeps working.

In onboarding (IP) mode the ports stay open on purpose for zero-friction first access; only secure mode locks down.

A fair question: could the installed software hide a threat — something that quietly runs an unwanted behavior? The honest answer is the strongest one: you are installing Open Code (source-available) software, so you can verify everything.

• Audit before going live. At any time you can ask an AI agent to run a detailed audit of the files installed on your own server. Your agent can confirm the installed code is safe and matches the public reference on Fractera's GitHub.
• Go as deep as you want. You can ask the agent to analyze every file on your server, not just ours. This is exactly the right instinct: we are entering an era where you should trust no one blindly, and installing files from someone else's source genuinely can carry hidden risk.
• Why ours stands up to it. The packages we install are maximally transparent — all from open source, so they can be inspected by any security team or accredited auditor without a shred of doubt. Source of truth: https://github.com/Fractera/Agent-Engineering-Infrastructure.

In short: don't take our word for it — have your AI agent check, before and after deployment.

By default the public pages of your site carry a small "Powered by Fractera" link — a crawlable back-link to the project. It is added at the web-server layer (not inside your app code), so it is consistent across your public pages.

Sponsors at the $5 tier (white-label) have it removed automatically and permanently — and if you rebuild your server, white-label status is reapplied so it stays removed.

Brain (Hermes) ships with a built-in web chat — a friendly chat panel that is the primary way you interact with the system. The moment your workspace opens, the chat is already there: it opens automatically in the admin panel, ready to use. The only thing you need to add is a model.

How it works. The chat is a thin, friendly front-end wrapped around the same Hermes agent running on your server. Your messages go to Brain, which thinks, queries Memory, and coordinates the coding agents, then replies in the chat. It reads the same single credential pool as everything else, so a provider you connect once works everywhere.

Where it lives. Inside the admin panel the chat opens automatically. On a custom domain it ALSO gets its own clean, auth-protected subdomain — chat.<your-domain> — so you can open it as a standalone "Remote Command Post" and manage the whole project from a light external link (even from your phone), without the full control panel. In IP mode it is reachable directly at http://<your-ip>:9120.

Login. The chat has no separate login of its own — its built-in registration / setup wizard is deliberately turned off (one credential store, not two confusing onboarding flows; you never set a chat password). On a fresh IP server the chat is open like the rest of the onboarding workspace. Once you attach a domain (secure mode), the chat — and the agent dashboard and Memory — are protected by Fractera's own authentication: you sign in once (admin role), and every internal port and subdomain is gated. So the chat is ready instantly, yet fully protected the moment you go secure.

Telegram is secondary and optional. It is not the main surface — it simply lets you *also* talk to Brain from your phone. Unlike the web chat (ready immediately, zero setup), Telegram needs setup: a @BotFather bot token in Settings → Telegram. Use the built-in web chat as your main tool; add Telegram only if you want a phone channel too.

Recommended model. Start with gpt-5-mini via the OpenAI API for both Brain and Memory — it costs about a cent per hour and is plenty to get going. Only switch to a Codex subscription once your usage would exceed roughly $20/month; below that, pay-as-you-go gpt-5-mini is the better deal.

Many providers offer a free daily quota on some of their models. You can optionally configure these free models in your workspace so that when one model's free limit for the day runs out, the agents fall back to another and keep working — without you paying anything. This is an extra option that the rich multi-model setup here makes possible: in a plain single-model dev setup you simply wouldn't have so many models to fall back across. It is not required — set it up only if you want to stretch usage at zero cost.

At key moments Fractera emails you. (Your server reaches the Fractera service, which sends the mail — you never configure an email provider yourself.) Typical messages: installation started; installation progress; a recovery token (to re-engage via the MCP agent if anything breaks); your server is ready (with the links); domain activated (secure mode live); certificate-expiry warning; deploy failed (with recovery options); and subscription / sponsorship notices. Always use a real address you control.

You manage everything from your Fractera dashboard at fractera.ai/dashboard: your servers — each with direct links to its app and admin panel — and your subscription / sponsorship status. The links shown adapt to whether a server is on a bare IP (plain HTTP) or a real domain (HTTPS).

A clear split. The product runs on your server (Open Code, all the layers above). An external Fractera service — operated by us — is what provisions it, delivers it and its updates, sends your emails, powers the dashboard and the MCP chat-deploy, and handles billing / sponsorship.

You interact only with the RESULTS of that service — the deploy, the dashboard, the emails, the MCP agent — and your code and data always stay on your server. (How that service is built internally is intentionally not part of this reference.)

Does Fractera store my server password?

No. When you deploy, your server's root password is used only in memory, for the few minutes of installation, to connect to the server and set it up. It is never written to Fractera's database — our records keep only a masked placeholder ("*****"), never the real password. This is enforced in code at every place a server record is created.

So can Fractera access my server later?

No. Because the real password is never stored, Fractera has no credential to authenticate with once installation finishes. There is no hidden key, no backdoor, no "support access". The connection that performed the install is closed and nothing is retained.

Then why must I change the password after deployment?

Two reasons. First, you typed the password to start the install, so as basic hygiene you should rotate it. Second, changing it is your own guarantee: once you set a new password that only you know, it is provably impossible for anyone — including Fractera — to reach the server with the original one. Changing it is your responsibility and a condition of using the service (see the Terms of Service).

Could I be hacked "because the password was with Fractera"?

No claim of that kind can hold. Fractera does not store the password and requires you to change it. If a server were ever compromised, the cause would be something else — a weak or reused password you kept, an exposed service, malware, a third party you shared access with — never retained Fractera access, because there is none. If you complete the password change, Fractera cannot retain access under any circumstances.

Who is Fractera, legally?

Fractera, Inc. is a registered Delaware C-Corporation (USA) with a real legal address, publicly accountable for its actions. Not an anonymous operator: we publish our Terms of Service and Privacy Policy and are bound by them.

Best practice — deploy on a clean server. For complete peace of mind, install onto a fresh VPS that holds none of your existing data. Then there is nothing pre-existing to worry about, and after you change the password the server is exclusively yours.

### 1. Acceptance of Terms

By accessing or using Fractera, you agree to be bound by these Terms of Service ("Terms") and our Privacy Policy. If you do not agree to these Terms, please do not use our services. These Terms constitute a binding legal agreement between you and Fractera, Inc.

### 2. About Fractera, Inc.

Fractera, Inc. is a corporation incorporated under the laws of the State of Delaware, United States. We provide a platform for deploying and managing AI coding environments on your own server infrastructure.

### 3. Description of Service

Fractera, Inc. provides a platform for deploying and managing AI coding environments on your own server infrastructure. We facilitate subdomain registration and server setup, but you retain full ownership and control of your server. We are not responsible for the content, security, or uptime of servers you provision.

### 4. Account Responsibilities

You are responsible for maintaining the confidentiality of your account credentials and for all activities that occur under your account. You agree to notify us immediately of any unauthorized use of your account.

### 5. Subscriptions and Payments

Some features of Fractera require a paid subscription. By subscribing, you agree to pay the fees set out at the time of purchase. Subscriptions are billed in advance on a monthly or annual basis. Most payments are processed by Stripe; alternative local payment providers may be used depending on your country of residence and will be displayed at checkout.

Cancellations and refunds are governed by our Refund Policy, which includes country-specific rights (EU 14-day withdrawal, Brazil 7-day regret, UK cancellation rights, and Australian consumer guarantees).

### 6. Acceptable Use

You agree not to use Fractera to:

• Violate any applicable local, state, national, or international laws or regulations.
• Infringe intellectual property rights of Fractera, Inc. or third parties.
• Transmit harmful, unlawful, defamatory, or fraudulent content.
• Interfere with the proper functioning of our services or servers.
• Attempt to gain unauthorized access to our systems or other users' accounts.

### 7. Intellectual Property

The Fractera platform, including its software, design, trademarks, and content, is owned by Fractera, Inc. and protected by intellectual property laws. Your subscription grants you a limited, non-exclusive, non-transferable license to use the platform for your internal business purposes.

### 8. Limitation of Liability

To the maximum extent permitted by applicable law, Fractera, Inc. shall not be liable for any indirect, incidental, special, consequential, or punitive damages arising from your use of the service, including but not limited to loss of data, revenue, or service interruptions. Our total liability to you for any claim arising from these Terms shall not exceed the amount you paid us in the 12 months preceding the claim.

### 9. Disclaimer of Warranties

The service is provided "as is" and "as available" without warranties of any kind, express or implied, including but not limited to implied warranties of merchantability, fitness for a particular purpose, and non-infringement.

### 10. Termination

We reserve the right to terminate or suspend your account at any time for material violations of these Terms, with or without notice. You may terminate your account at any time by contacting us. Upon termination, your right to use the service ceases immediately.

### 11. Governing Law and Dispute Resolution

These Terms are governed by and construed in accordance with the laws of the State of Delaware, United States, without regard to its conflict of law principles.

Any dispute arising from these Terms shall first be subject to good-faith negotiation. If unresolved within 30 days, disputes shall be submitted to binding arbitration in Delaware under the rules of the American Arbitration Association (AAA), conducted in English.

EU / EEA residents: Nothing in this clause limits your rights under mandatory consumer protection laws of your country of residence, including your right to bring a claim before your local courts or consumer authority.

### 12. Changes to Terms

We reserve the right to modify these Terms at any time. We will notify you of material changes by email at least 14 days in advance. Continued use of the service after changes take effect constitutes acceptance of the revised Terms.

### 13. Server Access Credentials & Your Security Obligations

To install Fractera on your server, you provide your server's IP address and root password. This password is used only transiently, in memory, to perform the installation. Fractera does NOT store your server's root password: our systems retain only a masked placeholder, never the actual credential. Once installation completes, Fractera has no technical means to access, log into, or control your server.

You acknowledge and agree that changing your server's root password immediately after installation is YOUR responsibility and a condition of using the service. You are solely responsible for the ongoing security of your server, including password rotation, firewall configuration, and access management. We strongly recommend deploying onto a fresh, clean server that contains no pre-existing data of yours.

Because Fractera does not retain your server password and requires you to change it after installation, any claim, demand, or theory of liability premised on Fractera having retained access to your server through the installation password cannot be sustained: where you fulfil your obligation to change the password, Fractera cannot, under any circumstances, retain access. Fractera, Inc. is a duly registered Delaware corporation accountable for its actions. Nothing in this section limits any mandatory consumer rights you may have under the law of your country of residence.

### 14. Contact

### 1. Introduction

Fractera, Inc. ("we", "our", or "us"), a Delaware corporation, is committed to protecting your privacy. This Privacy Policy explains how we collect, use, disclose, and safeguard your information when you use our platform. Please read this policy carefully.

### 2. Information We Collect

We collect the following categories of personal information:

• Account data: email address, name, and authentication credentials when you create an account.
• Payment data: billing details processed by Stripe or other payment providers. We do not store full card numbers.
• Usage data: log data, IP address, device type, browser, pages visited, and feature usage.
• Server data: the IP address and optional subdomain of servers you provision. We do NOT store your server's root password — it is used only in memory, during installation, and is never written to our database; we keep only a masked placeholder ("*****").
• Communications: messages you send to our support team.

### 3. How We Use Your Information

We use the information we collect to:

• Provide, operate, and improve our services.
• Process payments and manage subscriptions.
• Send transactional emails (account creation, billing receipts, password reset).
• Respond to support requests.
• Detect and prevent fraud or security incidents.
• Comply with legal obligations.

We do not sell your personal data to third parties.

### 4. Data Storage and Security

Your account and subscription data is stored on servers located in the European Union (Neon managed PostgreSQL, EU region). We implement industry-standard technical and organizational measures including encryption at rest and in transit, access controls, and regular security reviews. Despite these measures, no system is completely secure. Importantly, we never store the root password of the servers you provision: it is used transiently to run the installation and is then discarded, so Fractera retains no credential capable of accessing your server after setup completes.

### 5. Data Sharing and Third-Party Services

We share your information only with the following categories of service providers:

• Stripe — payment processing.
• Resend — transactional email delivery.
• Upstash — session caching (Redis).

We may also disclose your information if required by law, court order, or to protect the rights and safety of Fractera, Inc. or others.

### 6. EU / EEA Residents — GDPR Rights

If you are located in the European Union or European Economic Area, the General Data Protection Regulation (GDPR) grants you the following rights:

• Access: request a copy of the personal data we hold about you.
• Rectification: request correction of inaccurate data.
• Erasure: request deletion of your data ("right to be forgotten").
• Portability: receive your data in a machine-readable format.
• Object / Restrict: object to or restrict certain processing.

Our legal basis for processing is performance of a contract (subscription services) and legitimate interests (security, fraud prevention). To exercise your rights, contact us by email. We will respond within 30 days.

### 7. California Residents — CCPA Rights

If you are a California resident, the California Consumer Privacy Act (CCPA) grants you the following rights:

• Know: request disclosure of what personal information we collect, use, disclose, and sell.
• Delete: request deletion of personal information we have collected from you.
• Opt-Out of Sale: we do not sell personal information. No opt-out is necessary.
• Non-Discrimination: we will not discriminate against you for exercising your CCPA rights.

To submit a CCPA request, contact us by email or by mail at the address below. We will verify your identity before processing your request.

### 8. Data Retention

We retain your personal data for as long as your account is active and for a reasonable period thereafter to comply with legal obligations, resolve disputes, and enforce our agreements. You may request deletion of your account and associated data at any time.

### 9. Cookies

We use cookies and similar tracking technologies. Please see our Cookie Policy for details.

### 10. Changes to This Policy

We may update this Privacy Policy from time to time. We will notify you of material changes by email or by posting a notice on our platform. Continued use of the service after changes constitutes acceptance of the updated policy.

### 11. Server Access Credentials

When you provision a server through Fractera, you supply its IP address and root password. The root password is used only in memory, for the duration of the installation, to connect to and configure your server. We do NOT persist your server's root password to our database or any of our systems — only a masked placeholder ("*****") is retained. After installation, Fractera holds no credential capable of accessing your server.

Because we do not store this password, we ask you to change it immediately after installation and to manage your server's security yourself. See our Terms of Service for the corresponding security obligations.

### 12. Contact

The Fractera robot installs agentic engineering infrastructure on your VPS in 10 minutes.

• Zero to Production — Your VPS, domain, auth, database, and five AI platforms — live in 10 minutes. No cloud accounts to set up. No infrastructure decisions to make.
• Exit the Cloud — No Clerk. No Supabase. No Vercel. Auth, storage, and database run on your own server — one bill, one place, full ownership.
• Any Device, Full Speed — All computation runs on your VPS. Build from a laptop, tablet, or phone without hitting hardware limits.
• Ship 10× Faster — AI skips months of scaffolding. Production-grade starters mean your first feature ships in hours, not weeks.

Hermes Orchestrator: Multi-Model Agentic Loops

Hermes Agent by Nous Research, deployed and configured on your VPS. Coordinates Claude Code, Codex, and Gemini CLI through shared context. Switch to API mode for autonomous agentic workflows that run without your input — every loop refines the next.

LightRAG: Persistent Memory for AI Agents

A persistent vector store by HKUDS, shared across all five coding platforms. Your codebase, every architectural decision, every solved problem — always in context. No more starting each AI session from scratch. The company brain that compounds with every iteration.

Five AI Coding Platforms, One Server

Claude Code, Codex, Gemini CLI, Qwen Code, and Kimi Code — all preconfigured on your server. Run on your existing AI subscriptions. No API keys to manage, no per-token billing. Switch platforms mid-task without losing your project context — LightRAG keeps the thread.

Dedicated VPS Environment with Custom Domain

Dedicated Ubuntu 24.04 VPS configured automatically. Custom domain provisioned, SSL issued, Nginx routed — before you write the first line of code. Recommended provider: Contabo. 4 cores and 6 GB RAM is the minimum we recommend.

Pre-Configured Secure Database & Auth Stack

Google OAuth, magic-link email, SQLite with WAL mode, file storage, and vector store — preconfigured on your server. No Clerk subscription, no Supabase invoice, no separate email provider. One stack, owned by you, billed once through your VPS provider.

Monetize AI Workflows via Skills Marketplace

Package the workflows you've solved into reusable AI Skills. Sell them in the community marketplace, share them free, or buy battle-tested recipes from other builders. Your self-hosted stack becomes a passive revenue stream — your best work earns while you sleep.

Modern AI coding is easy — the hard part is owning the infrastructure. Fractera makes ownership effortless: a dedicated Ubuntu VPS, an automatic custom domain with SSL, and a production-ready product stack — all yours, forever.

1. Private AI infrastructure on your VPS — Buy once, and minutes later your own web infrastructure is live. You only add your VPS credentials a single time. The site, the admin panel, AI agents, memory, database, and storage all deploy and sync automatically. Everything belongs to you alone — not a single byte in someone else’s cloud.
2. Custom domain and SSL in a minute — The moment it deploys, your project is reachable and ready — over plain HTTP, which is plenty for early experiments. For everything else, connect your own domain: buy it from any registrar and attach it in under a minute. SSL certificate, DNS, and Nginx routing configure themselves.
3. Your domain triggers secure mode — Activating your own domain flips the server into secure HTTPS mode automatically. You sign in as administrator inside your own authentication platform. Later you can add more admins — but by default you’re the only one with access to the AI agents. No shared SSO, no third-party access console.
4. A full map of your server — Every important server event is mirrored to your email. So domain activation hands you a full map of what was built for you: the admin panel with agents, your public site, your Hermes orchestrator agent, a LightRAG knowledge base, your own auth platform governing every service, plus a database server and object storage.
5. Admin panel: five core tools — After signing in you land straight in the admin panel — mission control for your agents and web space. Five tools: a live preview of your main app; an agent selector carousel (Grok Builder lands soon); project settings; GitHub integration for local IDE work; and the Fractera skills marketplace.
6. Hermes orchestrator — your project core — Activate Hermes — the orchestrator agent you actually talk to. It routes tasks across AI agents, developers, and the memory agent. It can run on the OpenAI key you added earlier, but a Codex subscription is far more efficient: authorize in the browser and slash token spend on a powerful model. On a truly beefy server or home machine (AI company brain mode) you can skip subscriptions and use your own compute.
7. LightRAG — your project’s memory — Switch on your project’s global memory — it stores everything happening across your work and business. All it needs is an OpenAI key: the service is extremely frugal with tokens, just keep the balance positive. This vector memory is a future-defining edge: the more it knows, the fewer tokens your main AI agents burn.
8. Claude Code on your own server — Want to code with the Anthropic agent? Run /login and activate your subscription by following the prompts. From there you can write code right inside this terminal. But the priority, recommended path is working through the Hermes agent from Telegram — one entry point to every platform.
9. Codex: your key or subscription — Codex is available automatically the moment you activate your key in the previous step. To switch to a subscription, first leave registration mode with /logout, close the tab, and reopen it. Then repeat authorization, choose the subscription, and finish signing in by following the prompts.
10. Gemini — free production coding — No AI keys yet? Start with Gemini — it hands you a free trial and refreshes session limits every single day. The simplest way into production coding at zero cost. No command needed: just follow the authorization steps in order.
11. Qwen Code — an alternative engine — Qwen Code also runs on a subscription right in the terminal and is driven through Hermes. Every platform tackles broadly similar tasks, but each styles app interfaces differently by default. The design Qwen generates often comes out noticeably bolder.
12. Kimi Code — generous credits — Kimi Code runs on a subscription and serves as an alternative to the standard models. In certain scenarios it grants more generous credits for the same spend — a handy backup engine when you need more volume at the same price.
13. Your own database, zero cloud — The database is already installed on your server and wired into the project. For convenience the admin panel gives it a dedicated tab — a clear web UI to watch database health and make changes when needed. Under the hood it’s lightweight Postgres, and your AI agent already knows how to create and update data models with zero dependency on someone else’s paid cloud.
14. Your object storage, out of the box — The image processing and storage service is part of your server too, deployed automatically. Nothing to configure: start adding images to your project right away. Files live on your own disk, not in someone else’s S3.
15. A production starter from minute one — Your server ships with an app already built in: public and private routing, a clean structure built to grow, modern patterns, and solid scaling. Best of all, the starter saves you tokens and time — almost everything you’d normally build and integrate before the real work is already done. A preview is always in your admin panel, and the same version lives at your main address.

Production AI development happens entirely in your browser, from the first second. No VS Code. No local environment to configure. No database to spin up. No domain to wire. No deployment pipeline to debug. You open a tab — your server is already live, your domain is already registered, your database is already running, and five coding platforms wait for your first voice command. This is not just a tool for developers — this is the moment anyone with an idea can build, ship, and scale a real product without leaving the browser.

AI Coding in Browser — Open a tab, speak your intent, watch code appear. No IDE, no local setup. Five coding platforms run directly in your browser — terminals included.

Live in Production. Instantly. — Your server launches in seconds. One click deploys your changes live. No CI pipeline, no hosting configuration — just ship.

No API keys. No local setup. All five coding platforms run on your server with full terminal access and persistent LightRAG memory.

• Claude Code (Anthropic) — Writes, runs, and fixes code in your terminal. The gold standard for AI-assisted development workflows.
• Codex (OpenAI) — Browser-native coding agent. Full project context, no terminal required.
• Gemini CLI (Google) — Long-context coding agent. Understands your entire project structure in one prompt.
• Qwen Code (Alibaba) — Open-source coding agent. No subscription lock-in — powerful and free.
• Kimi Code (Moonshot) — Context-first model for large codebases. Excellent for refactoring and architecture work.
• LightRAG (Fractera) — Your company brain. Persistent vector memory shared across all five coding platforms.

* The project runs on your own subscriptions to the AI platforms — Fractera does not charge any additional fees or commissions for their use. You are free to connect one, several, or all five platforms — at your own discretion.

Modern AI development stacks are fragile, expensive, and forgetful. Here is what that costs you in practice.

Unpredictable Cloud Costs

The problem: Auth, storage, database, email — each service bills separately and scales with traffic. Free becomes paid, paid scales with load. Miss one payment and your live product goes dark.

How Fractera solves it: Fractera runs auth, databases, and storage on one server. One subscription, one bill. Cost does not scale with your users. Pause the business — your data stays safe.

AI Loses Context Every Session

The problem: Without persistent memory, every session starts from scratch. Tokens spent on "where is the navbar?" are tokens not spent on your feature. Two messages become fifteen.

How Fractera solves it: Fractera includes LightRAG — a persistent vector store that remembers your codebase and every architectural decision. Switch between Claude Code, Gemini CLI, or Codex without losing the thread.

Too Many Single Points of Failure

The problem: Ten services mean ten billing cycles, ten dashboards, ten places something can break. One service quietly expires — you do not know which one caused the white screen.

How Fractera solves it: Everything your application needs lives on one server. Code stays on GitHub — recovery is always possible. Built-in AI assistants can rebuild the project even with outdated packages.

Your Hardware Limits Your Output

The problem: Persistent memory, autonomous agents, five platforms in parallel — it pushes your machine hard. Performance drops the moment you open another tab. Not everyone has a dedicated GPU workstation.

How Fractera solves it: With Fractera your device carries zero load. All computation runs on your VPS. Scale cores and RAM when needed. Works on a laptop, tablet, or phone.

Your Data on Their Servers

The problem: Host on Vercel, store in Supabase, authenticate via Clerk — your business data sits on their infrastructure. One pricing change or one outage and your product goes down.

How Fractera solves it: Fractera moves auth, database, storage, and AI memory to a server you own. No third-party access to your data. No dependency on their uptime, their pricing, or their terms.

Install Fractera on your own VPS and get the full AI development environment — completely free, Open Code (source-available).

Free forever — Free — install on your VPS.

• Hermes — AI orchestration agent
• 5 coding platforms
• LightRAG — the company brain
• Database, file storage & auth — built in
• Open Code — self-hosted forever

Recommended Ubuntu 24.04 VPS Provider for AI Workloads. Fractera installs on any Ubuntu 24.04 VPS with 4 cores and 6 GB RAM. Contabo is our recommended choice — high-resource configurations at the lowest price point, popular among AI builders.

• Contabo — High-resource VPS at unbeatable prices. Popular for AI workloads. (from €3.60/mo)

Recommended Domain Registrar. A domain gives your server HTTPS, a memorable URL, and removes browser security warnings. Hostinger gives you direct DNS management without forcing a proxy — exactly what Fractera needs.

• Hostinger — Direct DNS management, broad TLD support, no mandatory proxy. (from $0.99/yr)

Fractera Light covers 90% of what a professional application needs. Fractera Pro unlocks the remaining 10%.

• Hermes AI Agents (For all users) — Fully configured agents with self-learning memory. The most powerful AI technology available in seconds — not hours of setup.
• Voice AI Commands (For all users) — Issue coding commands and navigate content hands-free via microphone. Agents respond to natural voice input in real time.
• Auth Stack Built-in (For all users) — Google OAuth, magic-link via Resend, and Credentials — all pre-configured with role management and enterprise sessions.
• Database & Storage (For all users) — SQLite with WAL mode, object file storage, and media service included. Scales with your project without extra subscriptions.
• Backups & Restore (For all users) — Snapshot your database and object storage at any moment, then upload the archive to restore your project or clone it into a new one.
• GitHub & Dev Workflow (For all users) — GitHub sync, production coding and local development unified. Push, pull, and deploy directly from the admin panel in one click.
• Platforms in 50ms (For all users) — All five coding platforms preconfigured and ready to use. LightRAG global memory initialized on first start. Zero setup time.
• Skills Marketplace (For all users) — Discover, buy, and sell automation workflows in the community library. Share free skills or monetise your own recipes.
• SEO, PWA & i18n (For VIP sponsors) — Production-grade SEO, Progressive Web App support, and multi-language routing — all configured before your first user arrives.
• Element Highlighting (For VIP sponsors) — Click any UI element to capture its exact identifier. Communicate precise changes to the AI — fewer tokens, faster iterations.
• Parallel Routing (For VIP sponsors) — Up to 11 parallel routing slots with static SEO: tabs within one window update each other's state with no page reload at all.
• Ready-made Sections (For VIP sponsors) — Prebuilt page blocks cut token spend many times over: header, footer, AI, tools, advanced SEO architecture and a design platform.

For B2B leaders who watch their company knowledge walk out the door every time someone leaves, every time a new hire joins, every time a meeting recap gets lost. The AI Company Brain is a single Mac mini in your office that captures the operating memory of your business — decisions, processes, voices, projects — and lets a Hermes-powered agent act on it on demand.

Fractera AI Company Brain is a physical Apple Silicon device (Mac mini or Mac Studio), personally configured by the Fractera founder, that combines two things you cannot buy off the shelf: a private LightRAG knowledge graph that ingests your meetings, documents, voice memos, emails and Slack history into a structured corporate memory — and a Hermes orchestration agent that uses that memory to do real work for you. A single box that replaces what would otherwise be a small team — a junior analyst, a project manager, a research assistant, a knowledge-base curator — and does it without forgetting, without leaving, and without leaking a single document into someone else's cloud.

How the AI Company Brain replaces a small team

Captures the memory your team keeps losing

LightRAG ingests every meeting recording, project doc, voice memo, customer email and decision log into a private knowledge graph. Names, dates, decisions, dependencies, "why we did it this way" — all linked, all queryable. When the founder asks "why did we kill that supplier last spring?" the Brain returns the meeting transcript, the email thread, and the deck — in seconds. No more Slack archaeology. No more "ask Anna, she remembers".

Acts on the memory — does not just store it

Hermes uses the Brain as its long-term memory and routes work to five subscription-grade AI specialists (Claude Code, Codex, Gemini, Qwen, Kimi) running on the same device. Brief it by voice from Telegram: "draft this quarter's investor update using last quarter's deck and our latest cashflow", "answer this customer email in our usual tone", "build a one-pager for the new product using our 2024 brand guidelines". The Brain remembers your context; Hermes turns it into shipped work.

Returns finished work as a link, not a chat scrollback

Every result comes back as a clean URL — a real document, a real deck, a real site, a real analysis. Open on your phone, project on the boardroom screen, forward to a teammate. This is the Iron Man moment: results, not prompt-engineering sessions. The Brain owns the institutional knowledge; Hermes owns the execution; you own the time saved.

Runs 24/7 on your desk — nothing leaves the building

The device runs in your office on Apple Silicon, sips ~30W, and never sends your knowledge graph or recordings to anyone's cloud. Schedule recurring jobs ("every Monday at 8am summarize what the leadership team agreed last week and what needs my attention this week"), or fire one-off requests. The Brain is awake while you sleep — you wake up to finished links in Telegram.

Pricing & delivery. By agreement — each AI Company Brain engagement is scoped individually because each business is different. Every package includes: founder-led memory audit (what knowledge your team is losing), the Apple Silicon device (Mac mini or Mac Studio), full LightRAG + Hermes + five-platform pre-installation tuned to your business, an initial ingestion of your existing meeting recordings / documents / Slack / email archive, hands-on training for you and your team, and 12 months of post-delivery support and process refinement. Year two and beyond — by separate agreement.

Strictly limited capacity. A small number of partner businesses per quarter. The depth of personal involvement by the Fractera founder is the value — and that requires bandwidth. If the next slot is full, we will tell you a realistic date.

Why we know this is exactly what you need. The AI Company Brain is the distilled life experience and business expertise of Fractera's founder. Dozens of personally shipped projects. Hundreds of allied companies. A thousand partners. And — most importantly — tens of thousands of hours of consulting, business development, and software engineering. Ready to amplify the memory and decision-making muscle of your business, and make it a sharper player in your niche. Just talk to us.

Apply for a founder consultation. Tell us about your business, the knowledge your team keeps losing, and what work you would hand to the Brain first if it were on your desk tomorrow. A short conversation with the Fractera founder is the first step — no commitment, no pitch deck, just a working session to see whether the AI Company Brain belongs in your office. (Email [email protected])

Why does Hermes reduce development costs rather than increase them?

There is a widespread belief that an orchestration layer like Hermes is wasteful — that it is better to talk directly to a coding model and skip the middleman. We disagree completely, and here is exactly why.

The real cost driver in AI-assisted development is not the number of requests — it is context window inflation. Every message in a direct coding session appends to the running context. After two or three hours on a typical project, the context is carrying the full transcript of the session. Most providers charge for both input and output tokens, and because every new message pays for everything before it, costs grow faster than linearly. Real-world data shows a Claude Code session on a mid-size project in hour three costs five to ten times what it cost in the first fifteen minutes. When you forget to manage the context window yourself — and everyone forgets eventually — that cost compounds.

Hermes is the external observer that prevents this from happening. It runs on inexpensive models (gpt-5-mini, qwen-turbo, and similar) that cost twenty to fifty times less than frontier coding models. These models do not need sophisticated reasoning — they read a spec, extract what matters, route a task, and immediately clear the context before the next call. That is exactly the work they are suited for.

• LightRAG eliminates session amnesia — without persistent memory, every new session spends the first 10–30% of its tokens re-explaining the project from scratch. LightRAG stores architecture, patterns, anti-patterns, and decisions, so the actual coding prompt can be laser-focused from the first word.
• Precise task specs from context — instead of a vague "build a dashboard", Hermes reads LightRAG and generates: "In app/dashboard/page.tsx, add a component using the Card pattern from components/ui/card.tsx, following the auth pattern from lib/auth.ts." This alone eliminates several back-and-forth exchanges per task.
• Immediate context clearing — after each task completes, Hermes clears the coding model's context. The next task starts with a clean slate, not carrying the entire previous conversation.
• Intelligent routing between models — simple tasks (documentation, refactoring, file renaming) go to cheap or free models. Complex architectural decisions go to frontier models. You pay frontier prices only for frontier work.
• Pattern and anti-pattern tracking — Hermes knows what approaches have worked in your project and which ones caused problems. It does not let the coding model re-discover the same dead ends.

This is only the surface. The deeper value is in what Hermes prevents: redundant searches for components that already exist, re-solving problems that were solved last week, sending the same context to five models in parallel when one focused call would do. Every one of those is a token cost that never appears on your invoice because it never happened.

We believe the future of efficient AI-assisted development is not about squeezing more out of a single model — it is about a system that knows your project well enough to ask the right model the right question at the right moment, and stop before it becomes expensive. That system is Hermes, and it is at the core of what Fractera is building.

The same AI platforms — yet Fractera ships faster with fewer tokens. Why?

Regular vibe coding puts all the heavy lifting on the AI: design the architecture, write boilerplate, locate the right component, recall what was decided last session. Every token spent on that overhead is a token not spent on your actual feature.

Fractera eliminates that overhead at every layer:

• Production-ready starters — Auth, database, file storage, and advanced routing ship fully pre-configured. The AI skips months of scaffolding and goes straight to your feature from day one.
• Component highlighting — Click any element on your live site to jump directly to its source. No tokens wasted asking "where is the navbar?".
• LightRAG, your company brain — A persistent vector store that remembers your entire codebase, every architectural decision, and domain knowledge. Every AI message arrives with full context.
• AI-optimized skills & instructions — Pre-built prompts and workflows designed for non-professional developers. The right approach on the first try.
• Cross-platform orchestration — LightRAG coordinates all five coding platforms so they share context. Switching from Claude Code to Gemini CLI doesn't mean losing the thread.

The result: tasks that take 10–20 back-and-forth messages in a vanilla AI chat typically resolve in 2–3 focused exchanges inside Fractera — token spend drops 70–90% compared to classic vibe coding.

This is Fractera Pro. And once you've tried it, there's no going back to plain vibe coding.

How does Fractera keep your business stable?

Modern web development has a tempting formula: combine a handful of "free" services — Clerk for auth, Supabase for your database, a dozen other cloud APIs. It looks great on day one.

The problems surface when your prototype becomes a real business. Each service quietly updates its pricing. What starts as free becomes a paid tier that scales with traffic.

Worse: ten billing cycles to track. Miss one and your project goes dark. No warning, no grace period. Partners who switched to Fractera often share this story: a live project lost because one service expired. By the time they figured it out, the reputation damage was done.

Fractera is built around a different principle: everything your business needs — authentication, databases, media storage — lives on your server, not spread across a dozen cloud dashboards.

• One subscription, one server — cost does not scale with your users.
• If you pause your business, your data does not disappear. Back it up and restore when you're ready.
• Your application code lives on GitHub — recovery is always possible, even if dependencies have aged.
• Built-in AI systems can help rebuild the project even when some packages are outdated.

One server. One bill. Maximum resilience — whether you are running one project or ten.

Do I pay per token for the AI, or use my own subscription?

You use your own subscriptions — that is the whole point. The five coding platforms (Claude Code, Codex, Gemini CLI, Qwen Code, Kimi Code) run on the subscriptions you already have: you sign in once with your normal account, like a local CLI. No API keys to manage, no per-token billing surprises. This is where the heavy AI work happens, and it costs you nothing beyond the subscription you already pay the AI vendor.

The only per-token piece is small and auxiliary: Brain (Hermes) and Memory (LightRAG) use one inexpensive OpenAI API key — the cheap gpt-5-mini runs at roughly a cent per hour and is plenty to get going. If your Brain usage grows heavy, you can switch it to a Codex subscription instead.

• Coding platforms (Claude Code, Codex, Gemini, Qwen, Kimi) — your existing subscriptions, no per-token billing.
• Brain + Memory — one small OpenAI key (gpt-5-mini, ~1¢/hour), or a Codex subscription if heavy.
• So a Claude Code user pays through their subscription, not per token.

What server specs do I need?

For full AI-coding workloads, the recommended minimum is 6 cores and 8 GB RAM. Storage depends on your project — 75 GB is a solid baseline.

Once active AI development wraps up, you can downgrade to 2 cores / 4 GB RAM — typically €1–2 per month.

Step by step — what does the full path from buying a server to monetizing my product look like?

The complete cycle: from an empty VPS to a live product on the marketplace. Under 30 minutes to launch, everything after that runs at your development pace.

1. Buy a VPS from Contabo (our recommended provider). Receive your IP address, login, and password.
2. On the "Your Server" tab, enter those credentials and launch the deployment. Watch real-time events for a few minutes. Two emails arrive: one when installation starts, another when it completes.
3. Your dashboard sits in the top-right corner — click your name after signing in. Inside you will find direct links to your live site and admin panel. The same links arrive in your completion email.
4. Sign up in the admin panel with a real email and password (save them carefully). The first user becomes the administrator — only admins can change settings. You can promote more admins later.
5. Have your own domain? Open "Settings", enter the domain name, copy the A-record. Set it at your DNS provider — and it works immediately.
6. Authorize one or more coding platforms (Claude Code, Codex, Gemini CLI, Qwen Code, Kimi Code). Codex is recommended as the channel for working through Hermes. Authorization is standard browser-based, just like in a local CLI. One-time setup.
7. Open Hermes and configure it your way. Add a messenger channel, or use the chat directly in the admin panel.
8. Tell Hermes what to change or what to generate. For example: "Let Claude do this and Codex do that" — both run in parallel through Hermes orchestration.
9. Upload documents (requirements, business description, any reference material) to your Company Brain — powered by LightRAG — manually, or ask Hermes to automate your data ingestion.
10. Want to accelerate? Ask Hermes to find a ready-made solution from the Fractera skills marketplace.
11. Your domain is live from minute one. After every development cycle, the site updates automatically — no manual deploy step.
12. Finished a project? Ask Hermes to turn it into a skill and publish it on the marketplace. Set a price, sell it, earn.

This loop repeats as many times as you want. Every product stays yours — on your server, under your domain, your code, your data, your subscriptions.

Roadmap & vision: where is Fractera headed?

When you start a business for the first time, almost everything around you is unfamiliar. Registering the company, opening a bank account, standing up a website and social profiles, streamlining production, finding traffic, balancing the unit economics, and finally scaling. An AI agent helps at every step — but it is not a single "do it all" button: it is a road you cannot walk in a day, or even a month.

Along that road the AI keeps proposing solutions. Some turn out right, some wrong; some save you money, some waste it, and once in a while income appears out of nowhere. Until now, this priceless zero-to-product experience lived only in your head. Now it can be digitized.

And this is nothing like reading a book or running through a checklist. The AI that solved every task alongside you, listened to your conversations, prepared your presentations — can assemble not a step-by-step manual but a living knowledge base. Not yes/no, but the complex conditional logic of decisions that modern AI can analyze and carry over — even to a different region, with different inputs and a different outcome.

So whoever is lucky enough to buy your digitized experience walks the same road faster and with far fewer mistakes. Admit it — you would want to be in their place too: to save years of your life and not pay for someone else's mistakes with your own money.

• More than a book — a book gives one route; the loop remembers the forks.
• More than a checklist — a checklist answers yes/no; the loop reasons in context.
• More than a course — a course teaches in general; the loop knows your exact path.

This is what we call the product loop — and it is the product we want to build in the near future.

Already have experience, or a company of your own? Want to digitize your current business — or your next one? Become a project sponsor: you join a private Telegram group where you can talk to the founder directly and be first to shape what our core service becomes — the product loop and its skill marketplace.

Stay with us — we will build it together.

Can I bring my existing project into Fractera and continue AI-assisted development?

Yes. Connect your existing GitHub repository to your Fractera workspace and start coding with AI immediately. Depending on your project's complexity, some initial migration steps may be needed — Fractera's built-in AI assistants can guide you through.

Can I deploy a finished project to Vercel instead of keeping it on my own server?

Yes — once a project is complete and no longer needs active AI-assisted development, you can export it to Vercel.

Important: moving to Vercel means leaving the Fractera environment behind. The AI coding workspace, terminal access, LightRAG memory, and all five development platforms only run on your own server.

Also keep in mind that Vercel and cloud storage pricing can escalate quickly under real-world traffic. Migrating back to a self-hosted Fractera server is straightforward — your code is already on GitHub.

Can I deploy a regular project without AI?

Yes — you can deploy a plain server with no AI at all. It is a common, deliberate choice, especially among experienced developers who want to offload the work of managing cloud resources and avoid DevOps overhead.

A server like this can be used at any time, synced with your home or work IDE (for example, Visual Studio Code), or simply to host and run your existing projects on infrastructure you control.

• Optional authentication — turn it on whenever you need it.
• Local database and object storage (for example, media) — included, with no cloud subscriptions.
• Freedom from cloud lock-in — meet regulatory or internal-policy requirements and avoid surprise bills.

A plain server like this needs only a lighter, more economical VPS. During deployment, switch to custom mode and tell us which services you want.

Don't worry if you turn off something you might need later — you can always add any recommended or custom AI tool through the terminal built into your admin panel.

Do I need a Claude Code subscription to deploy via the MCP connector?

Not necessarily. If the Fractera connector is your only custom MCP, you can use it on the free tier and get the full deployment service — no subscription required.

The condition is that you have not added another primary or custom MCP. If you already use a different custom MCP, you have two options: remove it before adding the Fractera connector, or move to a paid Claude plan (for example, Claude Pro, around €20/month), which lets you keep several custom connectors at once. Note this is Anthropic's own plan for the connector — it is unrelated to Fractera, which is always free.

Can I combine local development with the Fractera production platform?

Yes — and for developers with an existing local setup, this is often the most natural workflow.

If you prefer working with hot reload in your IDE, you don't have to change your habits:

1. After setting up your Fractera project, connect it to a GitHub repository and push the initial codebase.
2. Pull the code to your local machine. Develop the way you always have — your IDE, hot reload.
3. When ready to ship, push your changes to GitHub.
4. Return to your Fractera workspace, pull from GitHub, and hit Deploy.

Your changes go live in production in minutes. In effect, your own server becomes a self-hosted alternative to Vercel: GitHub is the bridge between your local environment and production.

Your local environment will continue to use the database and file storage that live on your server — no cloud subscriptions required.

Do you have a referral program?

Yes — the Fractera Partner Program. The model is simple and provider-agnostic: you recommend Fractera deployment, your readers buy a VPS from any host with an affiliate program, the host pays you directly.

Fractera doesn't pick the provider for you and doesn't restrict your choice. You decide who to work with: Hetzner, DigitalOcean, Vultr, Hostinger, RuVDS, Timeweb, Contabo — dozens of hosts run affiliate programs. Direct programs (RuVDS, Timeweb, Hostinger) approve in a day and pay up to 30–40% of the customer's first payment. Affiliate-network programs (Contabo via CJ.com, others via Admitad) pay a fixed amount per new customer but take a few days to approve.

The Fractera cabinet works with any affiliate link — we provide the infrastructure (mirror page, embed widget, MCP, cabinet), the host pays the commission.

For questions: [email protected]

How do I earn with Fractera?

Your income from partnership is closer and simpler than you might imagine. One approval at any hosting provider, then passive payouts for as long as your content keeps bringing readers.

1. Pick a host with an affiliate program. Direct programs are faster: apply on the provider's own site (Hetzner, RuVDS, Timeweb, Hostinger and others each have their own affiliate cabinet). Affiliate networks (CJ.com for Contabo, Admitad for several providers) are slower but unlock a catalogue of 3000+ brands through a single registration.
2. Get your affiliate link once approved by the provider.
3. Open the Fractera partners page, create your partner cabinet, add your affiliate link (or multiple links from different providers — the cabinet supports several at once).
4. Receive your personal Fractera landing mirror, an embed widget for your blog, and a single MCP link for AI agents. Your links replace the defaults in the "Where to buy a VPS" block.
5. Recommend Fractera in your blog, YouTube channel, social posts — wherever developers and entrepreneurs gather.
6. Any visitor who follows your link and buys a server from a partner host triggers a payout. Amount depends on the provider: direct programs pay up to 30-40% of the first payment, networks pay a fixed amount (Contabo: 20-55 € depending on configuration). The host pays you directly — Fractera is never in the middle.

The math is simple: one approval at one provider, then passive payouts for as long as your article, post, or video keeps bringing traffic. Hosts compete hard for new customers — and you get rewarded for every one you bring in.

Are you looking for regional partners?

Yes — and this is a different kind of opportunity. We are looking for official regional partners to build localized versions of Fractera together: adapted for local regulations, delivered in the native language of the region, backed by people who understand the local market from the inside.

This is not a reseller arrangement. A regional partnership means your own branded product, your own customer base, your own revenue stream — on an Open Code foundation that is already production-ready. The infrastructure is built. What a regional partner brings is market knowledge, local trust, and the ability to serve customers in ways a remote team cannot.

• Regulatory alignment — help your region meet local data residency and compliance requirements.
• Native-language support — technical support and documentation in the language of your customers.
• Your own business — not a franchise, a co-venture with full transparency into the product.