Developer Hub

Not a black box, A Programmable Platform

The whole of the 361 AI Operating System is exposed through endpoints: a JSON API, an MCP server, bidirectional webhooks, custom tool definitions, an embeddable chat component and definition-driven XML metadata. This page describes that surface exactly as it is — the view an engineering team wants before it signs off on an integration.

361 DEVELOPER PROTOCOL ARCHITECTURE

01 MCP Server Your own AI client uses 361 as a governed tool surface 02 Core JSON API One endpoint, 103 methods, one consistent response envelope 03 Webhooks & Events 361 triggers you, you trigger 361 04 Tool Definition 52 built-in tools plus your own 05 Chat SDK Dependency-free, white-labelable chat component 06 XML Metadata Business logic lives in the definition, not in code

01 · Model Context Protocol

361 is an MCP server

Your own AI client or agent can use 361 as a governed tool surface. Access to your enterprise data and business processes is bounded by permission buckets, entity-level access lists and an audit trail. The endpoint is /mcp.

JSON-RPC 2.0
MCP protocol version 2025-03-26
Server name: 361-platform-mcp
Transport: Streamable HTTP
POST only

Connecting

mcp-config.json

{ "mcpServers": { "361-platform": {
    "url": "https://<your-domain>/mcp",
    "headers": { "Authorization": "Bearer 361ai_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" } } } }

The key format is 361ai_ followed by 32 hexadecimal characters. Keys are never stored in plain text — only a SHA-256 digest is kept. Rotation has a transition window during which the old and the new key are both valid, so clients can be updated without downtime.

Supported methods

initialize — session start and capability negotiation
notifications/initialized — client-ready notification
ping — liveness check
tools/list — the tools the key is allowed to see
tools/call — tool invocation

Five permission buckets

Tool access is granted through five buckets rather than by managing individual tool names. When every bucket is open, a total of 60 tool names are mapped; in practice the set opened to a given key is a subset of that, determined by the key's permissions.

Permission bucket	Scope
entity_read	Reading, querying and aggregating records
entity_write	Creating, updating, deleting records and state transitions
config_read	Reading schema and configuration
config_write	Changing schema and configuration
utility	Helper operations, files, conversion, search

Access limits and auditing

Limits

Entity-level access list
IP allow list
Per-minute rate limit
Daily quota
Session expires after 30 minutes of inactivity

Audit trail

Every tool call is written to a daily JSONL file: timestamp, key identifier, tool name, arguments, success flag and duration in milliseconds. Sensitive fields such as passwords, tokens and keys are masked before they are written.

Limitation

The server does not speak stdio directly. Clients that only support the stdio transport need an HTTP → stdio bridge in between.

361 is also an MCP client

The direction is not one-way: 361 also consumes external MCP servers. Three transports are supported — HTTP/SSE, stdio and Streamable HTTP. Tools exposed by a connected server are discovered automatically and offered to the agents inside the platform.

02 · Core JSON API

One endpoint, 103 methods

The entire platform speaks through a single endpoint: /JSON. There are 103 methods in total, 38 of which run asynchronously. The method name travels inside the request body, so the only thing you need to learn is the envelope.

Request body

POST /JSON

{ "method": "Select", "params": { "et": "Customer", "inputparams": {} }, "urlpath": "" }

Response envelope

Response

{ "method": "Select", "code": "0", "message": "OK", "friendlymessage": "",
  "exception": { "message": "", "stacktrace": "", "source": "" },
  "result": { "items": [] } }

Note: code is a string, not a number. "0" means success — compare it as text on the client side.

Method families

Family	Contents
Session / bootstrap	16 methods — sign-in, context setup, domain information
Read / query	10 methods — listing, filtering, single record
Write	7 methods — Insert, Update, Upsert, Delete, Execute, Copy, Change
Field and state	SetField, Transition, Action, Procedure
Aggregation	GroupBy, GroupBys
Schema / metadata	30 methods — reading the schema at runtime
Message queue	Enqueue and consume
Files	Upload, download, attachment management
Real time	Notifications and live updates
AI	AiChat, AiChatStream, AiThreadList, AiThreadDelete
Bulk	Multi-record operations

GET paths

GET /JSON/Domain — domain definition
GET /JSON/Alive — 30-second liveness signal
GET /JSON/Select/<EntityType>[/<filter>[/all]] — direct read

The Select GET path honours the If-Modified-Since header; if nothing changed it returns a bodyless 304. That materially reduces bandwidth for frequently polling dashboards and mobile clients.

Error codes

Code	Meaning
102	params not supplied
110	Entity type does not exist
111	Entity type not available in this session
103 / 104 / 105	Problems with items (missing, malformed, empty)
9999	Unknown method

Idempotency — sending the same request twice

If you send a _requestId (UUID) with the request, the same request will not be executed again within a 24-hour window; the original response is returned verbatim. The mechanism was designed for the mobile offline queue scenario: when connectivity drops, queued requests can be resent without hesitation and no duplicate records appear.

Limitation

The idempotency cache lives in process memory. When the application restarts the cache is emptied and the request identifiers seen so far are forgotten. Account for this in critical flows.

03 · Event surface

Webhooks and events — both directions

Integration is not one-way. 361 can trigger your systems, and you can trigger an automation inside 361 from the outside.

Outbound — 361 triggers you

Webhook definition

{ "id": "wh_demo01", "name": "CRM Notification",
  "url": "https://example.local/webhook/ai-events",
  "events": ["agent:complete", "automation:done", "chat:message"],
  "secret": "whsec-xxx", "active": true,
  "headers": { "X-Custom-Header": "value" }, "retryCount": 3 }

Events you can subscribe to: agent:complete, agent:error, automation:done, chat:message, batch:complete, approval:pending.

Delivered payload

{ "event": "agent:complete",
  "timestamp": "2026-07-21T09:14:22Z",
  "data": { "agentId": "...", "agentName": "...", "result": {}, "duration": 1840, "tokens": 1265 },
  "signature": "sha256=..." }

The payload is HMAC-signed; verifying the signature on your side guarantees the request really came from 361. If your endpoint returns 5xx or times out, delivery is retried.

Inbound — you trigger 361

Setting an automation's trigger type to webhook makes it callable from the outside. The relevant fields are webhookPath, webhookSecret and webhookMethod (POST / GET / PUT).

Other triggers

Entity event

afterinsert, afterupdate, afterdelete. When one fires, every field value of the record enters the flow as a template variable — no extra query needed.

Scheduled

Interval, cron, daily or hourly. For example 0 9 * * 1-5 for 09:00 on weekdays.

Manual

Started by a user from the screen — for processes that need approval or run infrequently.

Inbound e-mail

An e-mail arriving in a designated mailbox starts the flow; used for request, order and invoice intake.

Flow steps

An automation flow is assembled from these steps: AI operation, create / update / upsert record, send e-mail, call webhook, condition, transformation, variable assignment, log and wait.

04 · Tools

Tool definition

The platform ships with 52 built-in tools. Every tool is defined with JSON Schema, and that schema is converted automatically into three provider formats — you never rewrite a tool to run it on a different model.

Category	Tools
Entity	8
Communication	2
Utility	12
Code	1
Database	7
API	8
Knowledge base	1
Entity files	2
Browser RPA	1
Channels	10

A real example: http_request

Parameters: url (uri, required), method (GET / POST / PUT / PATCH / DELETE), headers, body, timeout (default 30, maximum 120) and followRedirects.

SSRF protection: calls to localhost, 127.0.0.1, ::1, 10.x, 172.16-31.x, 192.168.x and 169.254.x are blocked — a model cannot use this tool to walk your internal network. Risk level medium; the call requires approval.

Define your own tool

Custom tool with a webhook implementation

{ "name": "crm_lookup", "displayName": "CRM Lookup", "category": "custom",
  "implementation": "webhook",
  "webhookUrl": "https://example.local/api/crm-lookup",
  "webhookMethod": "POST",
  "parameters": { "type": "object",
    "properties": { "customerNo": { "type": "string", "description": "Customer number" } },
    "required": ["customerNo"], "additionalProperties": false },
  "requiresApproval": true, "riskLevel": "medium",
  "maxCallsPerMinute": 60, "maxCallsPerConversation": 100 }

When the model calls the tool, the arguments are sent to your endpoint in the JSON body, a 30-second timeout applies, and the response is parsed as JSON and handed back to the model.

Honest note

Among the custom tool implementation types, javascript and pipeline are not implemented yet. The types that work today are webhook and MCP. Build your design on those two.

Tool security fields

requiresApproval — human approval before the call
riskLevel — low / medium / high / critical
Allowed agent list — which agents may call the tool
maxCallsPerMinute and maxCallsPerConversation — per-minute and per-conversation call limits

05 · SDK

Chat SDK — 361-chat.js

A dependency-free, plain JavaScript component for embedding an agent into your own web application, portal or customer site. Roughly 25-30 KB minified; no framework required.

Embedding

<script src="/ai-manager/361-chat.js"></script>
<script>
  Platform361Chat.init({
    agentId: 'musteri-destek-agenti',
    apiUrl: 'https://alan-adiniz.com',
    title: 'Musteri Destek',
    welcomeMessage: 'Merhaba! Size nasil yardimci olabilirim?',
    theme: 'light'
  });
</script>

Streaming and resilience

Responses stream over SSE; if SSE fails the component falls back to POST automatically and the conversation is not interrupted.

Theme and layout

Light and dark themes, customisable through 16 CSS variables. Below 480 pixels it switches to full screen.

Content

Markdown support: bold, italic, inline code, code blocks with a copy button, lists, headings and links.

Files and branding

Drag-and-drop file upload (up to 10 MB) and white labelling: your own logo, your own brand colour.

06 · Metadata

Business logic lives in the definition, not in code

Adding a field, hiding a field, calculations, business rules, state transitions and bulk operations are all done in the definition. Platform code changes only when a genuinely new capability is needed. This is the architectural choice that breaks the "development ticket for every request" cycle.

Entity definition

<Entity
  Name="TaskManagement"
  Title="Task Management"
  Title_TR="Gorev Yonetimi"
  HomeMenu="mBusinessManagement"
  Solution="BusinessManagement"
  Color="#CC4A65" />

Hierarchy

Metadata tree

Module
  Entities
    Entity
      EntityTypes
        EntityType
          Fields
          States
          DoScripts
          Contents
            Panel
          Navigation
          Roles

Multilingual metadata and runtime access

Multilingual metadata is built in: TR / EN / DE / FR / RU title fields are part of the definition.
The schema can be read programmatically at runtime. Through /JSON you use the ETs, Fields, RelatedFields, ETStates, EntityTypes and MetadataVersion methods — your client can build its own screen from the schema.
Schema changes do not require a restart.

07 · Environments

Environments, trial runs and limits

How safely an integration can be rehearsed before it goes live is the first question an engineering team asks. What follows are mechanisms that exist in the platform today.

You see what actually ran

361 agent execution traces — step tree with duration, tokens and cost — **Execution traces.** Every agent run expands as a step tree: how many steps it took, how long it ran, which tools were called. Debugging rests on the record, not on guesswork.

361 AI operation logs — request, response, status, provider and cost filters — **Operation logs.** What was asked, what came back, what it cost. Filter by status, provider and date; click a row to open the raw request and response.

Environment label

API connections are labelled Development, Staging or Production, so it is visible in the configuration which connection targets which environment.

Preview before you run

Synchronisation preview

Sample rows and mapped columns are shown before the transfer starts, so mapping mistakes surface without touching data.

Dry run for bulk operations

A dry-run mode, a revertible snapshot and tracking by operation id. A bulk operation that goes wrong can be rolled back.

Deployment plan preview

Before a solution deployment is applied, the changes it will make are listed as a plan.

Read-only lock

While the read-only lock switch in the database manager is on, every mutating operation is rejected before it is even sent to the server.

The code execution tool runs in an isolated sandbox with restricted file system and network access.

Honest note

There is no separate "sandbox tenant / test space" concept yet. Safety during trials comes from the preview, dry-run, rollback and read-only lock mechanisms listed above.

Authentication options

Supported on outbound connections: none, Basic, Bearer, API key, OAuth 2.0 (client-credentials / password / authorization-code) and Digest.

API key security

Keys stored as digests, never in plain text
Transition window during rotation
IP allow list
Per-minute rate limit
Daily quota

Let's get your engineers Around the Same Table

Detailed architecture and security documentation for your technical team is shared as part of the POC.

Start a Free POC Talk to the Technical Team