One name, one place.
A field lives on its tag. Renaming it is a single change.
The platform
One engine under every app.
Thogits is a platform for building business software quickly and reliably. Underneath sits Mantle, a proprietary engine written in Rust that collapses the five layers of a typical app into one.
Five layers of a typical app — database, server, API, state store and frontend — converge into Mantle, one engine for tags, records and sync.
01 · Database migration
02 · Server code
03 · API layer
04 · State store
05 · Frontend hooks
One engine
Mantle
tags · records · sync
The problem
Every feature touches five layers.
In a typical app, adding or changing one field means editing the same idea in five places, in five styles, and keeping every name in step. Each change then goes through review, merging and deployment before anyone can use it. AI coding tools face the same five layers: they write code faster, and every layer is still another place for a subtle bug.
- 01 Database migration
customer_status - 02 Server business logic
customerStatus - 03 API endpoints and types
customer_status - 04 State store state
customerStatus - 05 Hooks screens
useCustomerStatus - Branch → Review → Merge → Deploy → Repeat
The engine
Mantle turns five layers into one step.
With Mantle, changing the data model means defining or editing a tag. Screens bind directly to tags. The engine does the rest.
Local data captureOptimistic UILocal updatesServer syncMulti-client propagationStorage and querying
No deployment cycle.
Model and screen changes take effect in the workspace straight away.
Same for people and AI.
An AI agent edits a tag and a page: a small, well-defined surface to get right.
Example: add a priority field to the ticket tag and a dropdown to the ticket page. The field is stored, synced and live on every device, with no migration, endpoint or release.
Building blocks
A small set of blocks for almost any business app.
Tags, records, pages, backend functions, secrets, notification channels, permissions, and workspaces and users. They compose cleanly, and AI can assemble them reliably.
01
Tags
What an app stores
02
Records
Shared by every app
03
Pages
Custom screens
04
Functions
Custom logic
05
Secrets
Integration keys
06
Notifications
Alerts on change
07
Permissions
Who sees what
08
Workspaces
Users and invites
Next on the roadmap
Planned
Public pages: websites, portals and booking forms
Planned
Public functions: webhooks, APIs and integrations
Planned
Plugins: for example live calling or Postgres access
Each new block opens up a new class of apps you can run inside one workspace.
AI-native
All your business data in one place, open to AI.
- AI is built in. Within a workspace, AI can query, update and create records, always within the user's permissions. Built-in AI is powered by xAI.
- Every workspace has an MCP connector. Use the in-app builder, or connect Claude or another agent you already use. Either way, it writes on Mantle and the app is hosted here.
- Native references. Every app shares one data layer, so anything can reference anything else. A task can point at a customer; a document can reference a job.
- Live, connected outputs. Dashboards and reports draw on all of the business's data, live.
Why it matters.
~90%
less development time.
Our estimate, from building business apps the conventional way and on Mantle. The saving applies to people and AI alike.
Reliable by design.
Migrations, sync, API contracts and caches live in the engine. When a rare engine bug is found, it's fixed once and every app benefits at the same moment.
Fast by construction.
Mantle is written in Rust. Local capture and optimistic updates mean screens respond immediately while sync happens in the background.
Better as AI improves.
On Thogits, Claude, the built-in builder, or your own agent only has to define tags and build pages on a tested engine. The stack and the hosting are already there. Each step forward in AI widens the gap.
What we build
Fast when the app is made of blocks we already have.
Records, pages, permissions, notifications and the rest of the platform cover most business apps, and those go up very quickly. Anything outside those blocks takes more work, so it costs more. We add blocks over time, and we can build an urgent one for you now.
Photo coming
The engineering
Five years of engineering behind every app.
We spotted the pattern behind Mantle while building business apps: across app after app, the five layers repeated the same work. A repeating pattern can be handled by an engine, so we built one. We've worked on Mantle for more than five years, long before the current wave of AI tools, and we build every client system ourselves.
- 5+ years ago · pattern spotted
- Years of work · Mantle built in Rust
- Today · platform, engine and marketplace live
- Next · a growing library and client systems
Questions, answered.
Is Mantle open source?
Mantle is proprietary. It's developed by Thogits and runs under every Thogits app.
Where is my data stored?
Production databases and file storage are in the United States. The Privacy Policy lists every company that processes data for us.
Does it work with a patchy connection?
Yes. Changes are captured on the device first and sync in the background when the connection returns.
Why not use Claude?
You can. The advantage is the engine and the hosting, not the AI. Connect Claude or the built-in builder and the app is live for your team straight away. On your own, Claude still has to get the whole stack right, and you still have to deploy it.
Which AI provider do you use?
xAI powers the built-in AI, including the builder and in-app assistance. You can also connect Claude, or another agent, through MCP.
Can my developers extend it?
Yes. They can write pages and backend functions here, secrets store integration keys, and Claude or another agent can work through MCP. The workspace hosts the result.