Every Samna service is API first and ships its own command line tool and MCP server, so scripts and AI agents work with Samna inside the access you grant.
Command line tools, APIs and MCP
Every Samna service is API first and comes with its own command line tool. The same commands run in your terminal, in your scripts and in the AI chat you already use, inside exactly the access you grant.
Get a machine client
Create a client with sauth and grant it exactly the claims it needs, nothing more.
Install the CLIs
Install sauth, book, ssync, scon and sdm, sign in once and check each with a status call.
Give your agent the skill
One plugin install per CLI gives your agent the skill and the MCP server, globally or in the project.
Build on the API
Book, grant, sync, connect and manage devices from your own code, with the same rules the portals follow.
The API underneath
Every service is an API
Bookings, access, screens, sync, connections and devices answer in the same envelope, with the same paging, filtering and errors, described in OpenAPI.
Events you can follow
Subscribe to what happens: a booking held, a door opened, a device offline or a sync finished, signed and retried until your system has it.
Tengo where code helps
Most of Samna is set up without code. Where a rule does not fit a form, Tengo actions run safely inside the platform, written by you or by AI from a prompt.
Safe by design
Code and agents act as machine clients from Samna Auth, scoped to exactly the claims you grant them, and every call is audited like any other.
Command line tools
One CLI per application, with the same verbs, the same sign in through Samna Auth and an MCP server built in.
sauth for Samna Auth
Samna Auth from the terminal: apps, machine clients and their secrets, claims and grants, users, organizations and locations. Check exactly what a credential can reach before you hand it to an agent.
Create apps, vend machine clients and rotate their secrets, grant claims, and manage users, organizations and locations without opening the portal.
Every command runs as you or as a machine client, limited to the claims it holds, and every change lands in the audit.
Attach sauth over MCP and ask your AI chat who can reach what, or have it vend a scoped client for a new integration.
book for Bookable
Bookable from the terminal: bookables and bookings, Tengo actions and the AI that writes them, QR codes, calendars and webhooks, with the same rules the portal follows.
Set up bookables, read and change bookings, write and test Tengo actions, and manage QR codes, calendars and webhooks.
book follows the same booking rules and access checks as the portal, so a command never books what its credential may not.
With book as an MCP server your AI chat can find a free room, book it, or draft a Tengo action from a plain description.
ssync for Samna Sync
Samna Sync from the terminal: mappers that carry data between providers, connected tenants, guided migrations off legacy systems and every sync run they produce.
Build and run mappers between providers, connect tenants, follow every sync run and guide a migration off a legacy system.
ssync acts through a machine client from Samna Auth, and writeback only reaches the calendars a tenant has shared.
Let your AI chat explain why a sync failed, run it again, or set up a mapper from a description of the source and the target.
scon for Samna Connect
Samna Connect from the terminal: connections and connector templates, operations in and out, credentials on the expiry watch list, devices and the readings they send.
Create connections from connector templates, run operations in and out, watch credentials before they expire and read what devices send.
Credentials are sealed and never printed, and every operation runs with the access of the client that calls it.
Attach scon and your AI chat can call an operation, check the health of a connection or read the latest readings on request.
sdm for Samna Device Management
Samna Device Management from the terminal: enroll a device, list the fleet, roll out releases, follow live logs and set up the network, for every panel, box and mirror.
Enroll devices, list the fleet, roll out releases, follow live logs and take screenshots for every panel, box and mirror.
Each device is enrolled once into one governed connection, and every command goes through signed credentials.
With sdm over MCP your AI chat can tell you which devices are offline, pull their logs or roll a release out to a group.
The portals are built on the same APIs you get, so anything you can click you can also script, test and automate.
Every Samna CLI can run as an MCP server, through the CLI on your own machine or directly against the API. Your agent sees the same commands you do, limited by Samna Auth to exactly what its machine client may reach.
Through the CLI
Run sauth mcp, book mcp or any of the others locally and attach it to your agent over stdio. Nothing to host, and it uses the credential you already have.
Through the API
Point a remote MCP client straight at the Samna API for agents that run in the cloud, with the same tools and the same scoping as the CLI.
Scoped and audited
Every tool call carries the agent's own machine client, so it reaches only what you granted, and every call shows up in the audit with the rest.
Four steps from nothing to an agent that books, grants and schedules on its own, inside the rules you set.
Attach it to your agent
A terminal cycling through the sauth, book, ssync, scon and sdm command line tools
A terminal session with the {name} command line tool
Built for scripts and agents
The efficient office runs on surfaces that are easy to integrate. We simplify and automate the developer experience, so everyone can work safely with every part of their own stack, governed centrally or straight from their favorite AI chat.
From the terminal
Every core application ships a CLI with the same verbs, get, create, replace, update and delete, readable for people and predictable for scripts. Anything the portals do, you can do from the shell.
In your AI chat
Each CLI installs its own skill and serves its commands over MCP, so your agents work with Samna wherever they run, in Claude, Codex or any other MCP client.
Provisioning, bookings, syncs, connections and device rollouts become commands and scripts instead of tickets, handovers and slow onboarding.
Scoped and audited
Every person, script and agent acts through Samna Auth, scoped to exactly what it may reach, and every call is audited, whether it is governed centrally or enabled in a chat.
Safe by default
In your AI chat
Opening a new floor
A new floor used to mean a round of tickets to different teams. With the CLIs it is one session: a machine client for the panels, the rooms in Bookable, their calendars synced, the weather on the lobby screen and the panels enrolled.
Every step is a command you can put in a script, run again on the next floor, or hand to your AI chat.
A terminal session setting up a new office floor with sauth, book, ssync, scon and sdm
Ask your AI chat
Attach the MCP servers you need and ask in plain words. The chat calls the same commands you would, with the same limits and the same audit.
Which rooms on floor 5 are free after lunch?
Reads the bookings with book and answers with rooms and times, without changing anything.
Why did last night's calendar sync stop?
Follows the runs in ssync, finds the step that failed, explains it and runs the sync again when you say so.
Give the visitor app read access to the lobby screens.
Vends a machine client with sauth, grants only the claim it needs and shows you exactly what it can reach.
Which panels are offline right now?
Lists the fleet with sdm, pulls the logs from the panels that dropped and tells you what they say.
What is MCP?