An autonomous agent receives an objective, plans the steps, calls your tools, makes a decision when the case demands one, and reports what it did. The platform is live: 58 ready-made expert agents, a studio to compose your own, and four ways to expose them.
Both speak the same language. Only one of them changes what happens inside your information system.
| Autonomous agent | Classic chatbot | |
|---|---|---|
| Trigger | An objective: “process the invoices that arrived last night” | A question asked by a human |
| Reasoning | Breaks the objective down, plans the steps, reassesses when a step fails | One answer per message, no memory of a plan |
| Tool access | Calls your APIs, databases, business software and external services | Stays inside the conversation window |
| Effect | Writes into the system: creates, updates, notifies, triggers | Produces text |
| Memory | Task context, execution history, intermediate state | The current conversation thread |
| Control | Guardrails, human sign-off on sensitive actions, full audit log | Content filters |
Five steps, run at every launch. None is a black box: each leaves a trace you can read.
The agent receives a request — from a human, a system event, a webhook or a schedule. It extracts the real intent, the implicit constraints, and what is missing before it can act. If a decisive piece of information is missing, it asks rather than inventing it.
The objective is broken into ordered steps, each with the tool to call and the expected result. The plan is visible: on sensitive processes you can read it before execution, and require human sign-off at exactly that point.
The agent calls your systems: reading a database, searching the document layer, calling a REST or MCP API, writing into the CRM, generating a document. Every call is authenticated with the originating user's rights, never with an all-powerful service account.
When a step returns something unexpected — missing data, an amount outside the threshold, a contradiction between two sources — the agent does not force it. It replans, escalates to a human, or stops, according to the rule agreed with you for that case.
The agent reports what it did, what it read, what it wrote and what it could not do. The audit log keeps every call, every source and every decision — usable for internal control as much as for AI Act documentation.
These capabilities combine: one agent reads, decides, writes and notifies within a single run. The studio composes them without code, by switching on 59 capability bundles.
The orchestrator splits a mission across several agents working in parallel, reviewing each other, looping on points of disagreement, then assembling the deliverable. You watch the reasoning live in the thread.
Emails, forms, invoices, orders, tickets: the agent reads, classifies, extracts the useful fields and triggers the treatment, escalating the ambiguous cases.
A dedicated agent takes on large Excel and CSV files as well as SQL databases — PostgreSQL, MySQL, SQL Server, Oracle, MongoDB — and returns the calculation with the rows it used.
Slides on your PowerPoint template, professional documents, publishable websites and apps: the creation studio outputs the file in the expected format, not a draft to reformat.
Send an email, publish, schedule, create an opportunity, update a record. Sensitive actions go through human sign-off if you decide so.
A watch agent runs in the background, crossing technical, fundamental and sentiment analysis in parallel, and only writes when there is something to say.
The agent is the same in all four. You choose on security, integration and governance constraints — and you can change without rebuilding it.
| Exposure mode | What you get | Who it is for |
|---|---|---|
| Hosted platform | Ready interface, team and seat management, SSO, four languages including right-to-left Arabic | Starting with nothing to install, ready in 30 seconds |
| REST API | Full control: personal keys, durable run queue, streaming responses, usage tracking | Wiring the agent into your application or existing software |
| Embedded widget | One <script> tag, no back-end to write — the agent becomes your site's chatbot | Exposing an agent to your customers without leaving your site |
| White label | Your branding, on your domain | Reselling the agent under your own brand |
| On-premise | The full stack installs on your machines, including air-gapped networks with no internet access | Regulated corpus, sensitive data, contractual constraint |
| Your choice of models | vLLM, Ollama, Hugging Face, LM Studio, or managed APIs (OpenAI, Anthropic, Gemini, Mistral) | Sovereignty, cost, or performance depending on the case |
Per-account isolation, sandboxed execution, audit log, GDPR export and account deletion. An agent you build can also be published to the marketplace.
An architecture deliberately not tied to a single model vendor: the day a model changes price or policy, the agent does not stop.
These guarantees are properties of the architecture, not interface options. They can be verified, and that is usually what gets a project through.
| Guarantee | What it means concretely |
|---|---|
| Isolated execution | Generated code runs in a hardened sandbox with no network access, read-only, with memory and wall-clock ceilings. |
| Controlled egress | A single audited outbound path, allowlisted, with protection against requests aimed at your internal resources. |
| Prompt-injection guard | As soon as untrusted content enters a run — a web page read, a scraped document — side-effect and exfiltration tools are disabled for the rest of the turn. |
| Isolation | Separation by organisation, team and user. The agent's rights are those of the person who launched it, never a technical account. |
| Organisation secret vault | An admin stores a key once; members use it without ever being able to read it. Revoking the secret revokes every use of it at once. |
| Enterprise identity | Per-organisation OIDC SSO, automatic account provisioning, and clean suspension when the organisation changes plan. |
| Audit log and SIEM | A complete trail, exported to your collector — read in scheduled batches, never in the path of a login. |
| GDPR | Account deletion with deferred purge, per-organisation conversation retention, data export. |
| Budget and kill-switch | A per-organisation daily and monthly spend ceiling enforced at the front door: beyond it the request is refused rather than billed. |
The web studio preview runs in an opaque origin: generated HTML can never reach any of the application's tokens. And browser-side writes take their identity from the signed token, never from the request body.
The platform is used from its interface, but everything it does is available through the API too: personal keys, a durable run queue, streaming responses and usage tracking.
# Launch a mission and stream the response.
curl -N https://ai.syctra.com/api/v1/runs \
-H "Authorization: Bearer $SYCTRA_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"agent": "market-desk",
"input": "Market note on our three competitors, dated sources.",
"stream": true
}'
# The run queue is durable: a long mission survives a client
# disconnect, and can be read back by its identifier.<!-- An agent becomes your site's chatbot.
No back-end to write, no key exposed in the browser. -->
<script
src="https://ai.syctra.com/embed.js"
data-agent="customer-support"
data-locale="en"
defer
></script># Create a knowledge base and load a corpus into it.
# Up to 100 MB and 1,500-page catalogues, via batch OCR.
curl https://ai.syctra.com/api/v1/knowledge-bases \
-H "Authorization: Bearer $SYCTRA_API_KEY" \
-F name="Supplier contracts" \
-F files=@contracts.zip
# Answers cite their sources: every clickable [N] opens
# the exact page of the original PDF.# The full stack installs on your machines,
# including air-gapped networks with no internet access.
models:
provider: vllm # or ollama, lm-studio, hugging-face
base_url: http://internal-gpu:8000/v1
network:
egress: deny # no outbound calls
storage:
isolation: per-account
audit_log: true
compliance:
gdpr_export: true
account_deletion: truePer-account isolation, sandboxed execution, audit log, GDPR export and account deletion. Irreversible actions go through human sign-off, by design.
Deliberately narrow perimeters: an agent that does one thing well beats an agent that does ten things badly.
Three hundred invoices a month arrive by email, in ten different formats. One person keys them in, another matches them to purchase orders.
An agent reads every attachment, extracts supplier, amount, VAT and references, matches against the purchase order in the ERP, and escalates only discrepancies and unknown suppliers.
Data entry disappears. The team handles exceptions instead of volume, and every match is justifiable in one click.
Inbound requests from the website and trade shows land in a shared mailbox. The best ones get handled, the rest go cold.
An agent qualifies each request from the message and public sources, enriches it, creates the opportunity in the CRM with a score and written context, and alerts the relevant rep.
No request sits idle. The rep opens a case already worked rather than a three-line email.
Every new hire triggers fifteen tasks split between HR, IT and the manager, tracked in a spreadsheet.
An agent orchestrates the onboarding sequence: account creation via API, sending documents, chasing late owners, answering the newcomer's questions from internal procedures.
Onboarding runs without manual chasing, and the gap between planned and actual is visible in real time.
The first two figures come from the search engine feeding the agents, measured on a public question-answer set. The third is the pace of our projects.
ready-made expert agents — legal, finance, recruiting, translation, prospecting
to first results from the search engine, at over 500 concurrent queries
between pilot launch and the decision to industrialise or stop
These orders of magnitude come from what we measure at pilot on comparable perimeters. On your corpus they are measured before industrialisation, not promised before.
These products are already built. Some are available online, the others are shown on request.
Build your own AI agents without writing a line of code.
Tools, long-term memory, connectors, guardrails and supervision in a single interface. Your teams design an agent in the morning and ship it to production in the afternoon, on your data.
Try it onlineSeveral agents splitting the work and reviewing each other.
Where a lone agent gets it wrong, a swarm converges: each one handles its share, critiques the others, and the result is consolidated. For large-scale document analysis and tasks that run dozens of steps deep.
Try it onlineThe chatbot answers in a window. The agent receives an objective, plans, calls your tools and writes into your systems. If your need is to answer questions, a support assistant is enough and costs less — we will say so.
Its action perimeter is declared: it can only call authorised tools, with the originating user's rights. Irreversible actions go through human sign-off. And every call is logged, so it is reversible and auditable.
No. We wire into what exists: REST APIs, databases, ERP, CRM, internal tools. Where there is no API, the software pole builds one — that is often the real project.
Two to three weeks of scoping, then six to ten weeks of pilot in real conditions. An agent on a narrow perimeter can be visible sooner, but the integration with rights and systems is what takes the time.
A standard protocol that tells an agent which tools it has and how to call them. In practice it avoids writing one bespoke connector per tool: if your service exposes it, the agent knows how to use it.
The architecture is not tied to a single vendor. Models are interchangeable, including sovereign or self-hosted ones. That is a design decision, not an option bolted on afterwards.
No. The studio composes an agent by switching on 59 capability bundles, without writing a line. The API exists for those who want to go further, not as a mandatory step.
Yes, the full stack installs on your machines, including air-gapped networks with no internet access, with your own models served locally by vLLM, Ollama, LM Studio or Hugging Face.
In credits: one million tokens is a thousand credits, roughly $1.11. Unused credits roll over month to month and never expire; if you cancel, they stay yours. A typical presentation mission costs a few dozen credits.
An autonomous agent is not the right answer to a poorly defined process. If nobody in the organisation can describe the current rules, automating will only accelerate the mess — so we start by writing the process, which belongs to the software pole. Nor do we let an agent single-handedly trigger an irreversible financial or legal action: those steps go through human sign-off, by design.
Describe it in two lines. In thirty minutes we will tell you whether it can be automated, on what condition, and where to start.