How AITIZER works.

Overview for builders and developers · updated 13 September 2026

1. Four concepts

• Workspace is the tenant. Every table, agent, app and invoice belongs to one. Members have roles; branding, subdomain and custom domain live on the workspace.
• Smart Tables are your database. Each table is a real Postgres table underneath; columns can hold plain data or compute something (formulas, HTTP calls, records in other tables, AI).
• Everything is reachable through the MCP server and the REST API with a workspace token. Outbound HTTP always goes through a server-side proxy so credentials never reach the browser.
• Vibe Coding is the AI that reads your workspace through MCP and builds full apps on top of it: screens, login, permissions, integrations, publishing.

2. Smart Tables & column types

Create a table, add columns, type or import data (CSV/XLSX). Views are saved lenses on a table: grid, kanban, gallery, form and custom (HTML/JS built by the AI). Views can be shared publicly with a link and an optional password.

Plain columns

text, number, date, checkbox, single_select, multi_select, relation (link to a record in another table), file.

Computed columns

They run automatically when a record is created or edited, in column order, and can reference other cells with {Column Name}:

• formula. Excel-style expressions (SUM, IF, CONCAT, DATEDIFF…) or sandboxed JavaScript.
• http_request. Call any URL with headers and body; json_parser extracts a path from the response.
• action. Run a Special Field request (a reusable integration endpoint).
• create_record, update_record, delete_record, fetch_records. Cross-table automation without code.
• loop. Iterate an array; following columns run once per item with {$item} and {$index}.
• ai_agent. Ask one of your agents to fill the cell (summaries, classification, extraction).
• delay. Wait before the next step.

Tables can also be vectorized for semantic search (embeddings updated on every change) and scheduled so a computed pipeline runs on a cron.

3. Special Fields. Integrations

A Special Field group is a folder for one external service (Stripe, Twilio, Slack, your own API). Inside it you define requests: method, URL, headers, body and smart tags written as {{tag}} that are filled from cells at run time. Credentials are stored encrypted and injected server-side; three modes exist:

• Admin credential. One key set by the workspace admin, used by everyone, never shown to the browser.
• Editor credential. Each editor fills their own fields (their Slack token, their account id).
• Platform key. Uses the platform's LLM keys; metered in AI credits.

When the AI building your app needs a key you have not provided, it opens a request in the Connections tab and keeps building; you paste the key later and the automation goes live.

4. AI Agents & channels

An agent has a system prompt, a model (Anthropic, OpenAI or Google), a temperature, an optional voice, and an optional MCP server so it can read and write your tables. Connect it to channels:

• Web chat. A public page or an embeddable widget with three visual templates.
• WhatsApp. WhatsApp Cloud API (phone number id, access token, verify token).
• Telegram. A bot token.

Every exchange is logged with its cost in credits and deducted from the workspace's AI credits.

5. MCP server & REST API

Create a token in API Credentials and link it to an MCP Server, where permissions are set per table (read all / read own / create / edit / delete). Three token types: user_mcp (MCP protocol, 12 tools), rest_api (REST endpoints) and the admin-only Vibe Builder credential (all 54 MCP tools + REST). Tokens can expire, are shown once, and can be rotated or revoked; every call is logged.

MCP server (Streamable HTTP, spec 2025-06-18)

Endpoint: https://api.aitizer.com/functions/v1/mcp-server. Send Authorization: Bearer YOUR_TOKEN. JSON or SSE responses according to your Accept header, Mcp-Session-Id issued at initialize, ping, paginated tools/list, tool annotations. Claude Code, Cursor and Codex connect directly. No local bridge:

# Claude Code
claude mcp add --transport http aitizer https://api.aitizer.com/functions/v1/mcp-server \
  --header "Authorization: Bearer $AITIZER_MCP_TOKEN"

# Claude Code. .mcp.json (project scope; safe to commit, the token comes from the environment)
{ "mcpServers": { "aitizer": { "type": "http",
    "url": "https://api.aitizer.com/functions/v1/mcp-server",
    "headers": { "Authorization": "Bearer ${AITIZER_MCP_TOKEN}" } } } }

# Cursor. .cursor/mcp.json (paste the token; keep the file out of git)
{ "mcpServers": { "aitizer": { "url": "https://api.aitizer.com/functions/v1/mcp-server",
    "headers": { "Authorization": "Bearer YOUR_TOKEN" } } } }

# Codex. ~/.codex/config.toml
[mcp_servers.aitizer]
url = "https://api.aitizer.com/functions/v1/mcp-server"
bearer_token_env_var = "AITIZER_MCP_TOKEN"

# Claude Desktop. Custom connector (URL only, so the token travels in the URL; prefer the clients above)
https://api.aitizer.com/functions/v1/mcp-server?token=YOUR_TOKEN

# curl. Initialize, then call a tool
curl -i -X POST https://api.aitizer.com/functions/v1/mcp-server \
  -H "Authorization: Bearer YOUR_TOKEN" -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'
curl -s -X POST https://api.aitizer.com/functions/v1/mcp-server \
  -H "Authorization: Bearer YOUR_TOKEN" -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"list_tables","arguments":{}}}'

The 54 tools (live list, always current: GET https://api.aitizer.com/functions/v1/mcp-server/tools). Available to every token: check_column_types (live column-type catalog), list_tables, list_columns, list_records (filters by label or id, real totals), get_record, create_record, update_record, delete_record, compute_cell (re-run one computed column), list_views, semantic_search (embedding search on vectorized tables), sql_query (read-only SQL with human-readable names: WHERE with =, !=, LIKE, IN, IS NULL; ORDER BY; LIMIT/OFFSET; COUNT). Vibe Builder only: request_credential, create_table, delete_table, create_column, update_column, delete_column, create_view, update_view, delete_view, list_special_field_groups, list_special_field_requests, get_app_auth, set_owner_column, create_app_user, publish_app, unpublish_app, set_public_tables, create_schedule, list_schedules, delete_schedule, run_schedule, list_ai_agents, create_ai_agent, update_ai_agent, get_ai_agent, delete_ai_agent, list_agent_options, list_mcp_servers, create_mcp_server, get_mcp_server, set_mcp_table_permissions, create_agent_channel, list_agent_channels, update_agent_channel, delete_agent_channel, add_agent_knowledge, update_agent_knowledge, delete_agent_knowledge, add_agent_tool, delete_agent_tool, set_agent_intake_fields, test_ai_agent. Column types use the type field (alias column_type), for example {"name":"Price","type":"number"}.

REST API

Full reference with every route, filter operator, body and limit: aitizer.com/api.

Base https://api.aitizer.com/functions/v1/rest-api, same Bearer header. Routes: GET/POST /tables, DELETE /tables/{id}, GET /agents, /tables/{id}/columns[/{colId}] (GET/POST/PATCH/DELETE), /tables/{id}/views[/{viewId}] (GET/POST/DELETE), /tables/{id}/records[/{rid}] (GET with filter[Field][op]=, sort, limit/offset; POST/PATCH/DELETE), POST /tables/{id}/records/batch, POST /tables/{id}/records/{rid}/run, POST /tables/{id}/records/{rid}/compute/{column}, POST /tables/{id}/run-actions, POST /sql, GET /special-fields/groups[/{id}/requests].

# List tables
curl https://api.aitizer.com/functions/v1/rest-api/tables \
  -H "Authorization: Bearer YOUR_TOKEN"

# Create a record (computed columns run server-side)
curl -X POST https://api.aitizer.com/functions/v1/rest-api/tables/123/records \
  -H "Authorization: Bearer YOUR_TOKEN" -H "Content-Type: application/json" \
  -d '{"fields": {"Name": "Ada", "Amount": 1200}}'

# Filter + sort + paginate
curl "https://api.aitizer.com/functions/v1/rest-api/tables/123/records?Status=eq.Active&Amount=gt.100&order=created_at.desc&limit=20" \
  -H "Authorization: Bearer YOUR_TOKEN"

# Read-only SQL with human-readable names
curl -X POST https://api.aitizer.com/functions/v1/rest-api/sql \
  -H "Authorization: Bearer YOUR_TOKEN" -H "Content-Type: application/json" \
  -d '{"query": "SELECT Name, Amount FROM Orders WHERE Status = '"'"'Paid'"'"' ORDER BY created_at DESC LIMIT 20"}'

6. Vibe Coding & publishing

Describe the software. The agent creates the tables it needs, writes a React app that talks to your workspace, adds login for your end users, wires Special Fields and shows a live preview with hot reload. Three effort levels (Lite, Balanced, Max) trade speed for reasoning depth. Each build runs in an isolated sandbox.

Publish puts the app on a URL under your workspace (and, on Pro and above, your own domain), as a PWA if you want. Dev Pack and Git give developers the repository with ready MCP configuration files for Claude Code (.mcp.json), Cursor (.cursor/mcp.json) and Codex (~/.codex/config.toml). The token lives in the AITIZER_MCP_TOKEN environment variable, never in the repo. So the same 54 tools work in their own editor; pushing back updates the live preview. Desktop and Android installers can be generated from the same project.

7. AI credits

Credits are the single unit for everything AI does (builds, agents, automations). The number you see in the usage panel is exactly what is deducted. Heavier models cost more credits per token (the multiplier is shown next to each model). Every plan includes a monthly allowance; you can add packs or, on Pro and above, enable automatic recharge with a hard monthly cap. Bring your own API keys or Claude subscription and that usage costs zero credits. Details and current numbers: pricing.

8. Workspaces, roles & app users

Workspace members (super admin, admin, editor, viewer) are your team; they log into AITIZER. App users are the people who log into the apps you publish; they live in a protected Users table in each workspace, never see AITIZER itself, and can be limited to their own records. Plans count the two separately.