High-level entities
Trellaris is an enterprise AI agent platform. Four entities do most of the work — Agents, Tools, Connectors, and Skills — and they are layers, not siblings.
The four core entities
| Entity | What it is | How it's declared | Analogy |
|---|---|---|---|
| Agent | The actor you chat with or automate. The unit of identity, governance, versioning, and execution. | An Agent.md definition |
The employee |
| Tool | A single verb the model can call mid-run — search the web, run code, get the time. | Listed in the agent's tools: |
An action |
| Connector | A special kind of tool that reaches an external system as the user, via delegated OAuth. | Connector name in tools: |
An action performed while signed in as you |
| Skill | A packaged, reusable playbook — instructions plus optional sandbox scripts — that sequences which tools to use, when. | Attached via the agent's skills: |
The written procedure |
The relationships that matter:
- A connector is a tool — a governed, delegated one.
- A skill uses tools, but only ones the agent already grants
(a skill's
allowed_toolsmust be a subset of the agent's tools). A skill packages know-how, never access. - The agent grants tools and connectors and attaches skills. It is the thing that actually runs, carries the identity, and enforces policy.
Supporting entities
Run
One execution of an agent. Carries status, streamed events, artifacts, cost, and its own audit trail.
Knowledge
Collections of ingested documents, chunked and embedded, retrieved with citations and permission filtering.
Memory
Durable facts about the user or agent, deduplicated and auto-injected into later turns.
Orchestrator
A built-in supervisor agent: plans a goal, routes each step to the best visible agent, then synthesizes.
Tools Library
Registered MCP servers — external tool servers reviewed, promoted, and resolved through one path.
Policy
Org-scoped governance: DLP, allowlists, budgets, approvals, autonomy floors, browser egress, and more.
Automation
Runs an agent when something happens — a schedule, a webhook, a watched page, inbound mail.
Promotion
The reviewed path from a personal agent to one a whole department depends on.
Avatar
Your own agent that answers about you and for you — from a profile, a knowledge pool and a memory pool you curated — reachable by name or @handle.
Chart
An interactive chart an agent drew from a full ECharts option — validated, redacted, kept with the message, updatable by id.
What the platform does
A map of the whole feature surface, and where each part is documented.
| Area | Capabilities |
|---|---|
| Author | Agent.md and SKILL.md definitions, live validation, a Monaco editor, 16 governance-ready templates, 20 built-in skills, an Architect meta-agent, and the Skill Workshop. |
| Act | Built-in tools for web, code, media and everyday utilities; delegated connectors; MCP servers from the Tools Library; governed browser use. |
| Know | Knowledge collections with cited retrieval and mirrored source permissions, synced sources, chat attachments, and per-user or per-agent memory. |
| Assure | Five-stage security scanning, evaluation sets with regex, schema and rubric assertions, promotion gates, staged rollout, continuous sampling and demotion. |
| Scale | A supervisor orchestrator, background runs and Deep Research, fan-out over lists, and agent-scheduled wake-ups — each individually bounded. |
| Trigger | Cron, webhook, watch, email-in and wake-up automations; Slack and Teams channels; inbox, email, DM and webhook delivery. |
| Govern | Ten runtime policy kinds, approval gates, kill switches, privacy tiers, legal holds, audit and SIEM export, a risk register, and a Compliance API. |
| Integrate | Chat, canvas and voice; an MCP gateway and MCP exposure; A2A in both directions; a full REST API with scoped keys and a secrets vault. |
| Represent | A personal avatar per user with per-field profile visibility, owner-scoped knowledge and memory, persona and guardrail configuration, consents and an activity log; @handles for every agent. |
| Show | Interactive surfaces (forms, choices, uploads) and charts drawn from a full ECharts option; the built-in Market Watcher agent for market data. |
| Operate | Run replay, OpenTelemetry GenAI spans, model auto-routing and failover, cost dashboards, showback, SLOs and ROI, and a three-tier Helm deployment. |
| Architecture | How it is built: the functional composition, the six steps of a run, the deployment topology, the module map, the extension seams, the tech stack, and every open-source package. |
| Administer | Organizations, teams and workspaces, SSO and social sign-in, domain capture, SCIM provisioning with a deprovisioning cascade, and plan limits. |
How a request flows
A message arrives (chat, a schedule, a webhook, a Slack mention). The platform creates a run and hands it to the executor, which:
- Loads the agent's current version and assembles its tool registry — built-in tools, connector tools, MCP tools from the library, plus tools switched on by configuration (skills, memory, knowledge).
- Builds the system prompt — the guardrail preamble, the agent's role, a skill index, and any injected context (attached documents, memories, knowledge citation rules).
- Streams the model turn, executing tool calls as they come. Reads run immediately; writes park for approval unless policy says otherwise.
- Applies governance at every boundary — input and output DLP, tool allowlists, budget checks, injection screening on anything read back from the outside.
- Persists the answer, the artifacts, the token/cost ledger, and the event stream (so the turn can be replayed later).
Where things live
| Data | Store |
|---|---|
| Agents, skills, runs, conversations, messages, policies | PostgreSQL (with pgvector for embeddings) |
| Live run events (tokens, tool calls, status) | Redis stream per run — ephemeral, for streaming and replay |
| Documents, generated artifacts, skill bundles | Object storage (S3/MinIO, or Azure Blob) |
| OAuth tokens and secrets | Encrypted at rest; resolved server-side only, never returned |
Multi-tenancy and visibility
Every entity is owned by an organization, and every query is org-scoped at the repository layer — tenancy is not optional. Within an org, entities live in rings that control who can see them:
- Personal — only the owner.
- Team — members of that team.
- Org — everyone in the organization.
- Public — shared beyond the org.
Moving an agent from personal to a shared ring is a promotion: it must pass a security scan and evaluation floors, then a human reviewer approves it. See Agents for the full lifecycle.
Next
Agents →
Definition format, rings, versions, promotion, and lifecycle.
Tools →
The built-in catalog and how tools are enabled per run.
Connectors →
Delegated access to external systems, and the approval gate.
Skills →
Reusable playbooks with progressive disclosure and scripts.
Governance →
The seven layers of control, and how each one is enforced.
Policy reference →
All ten policy kinds, in detail.
Architecture →
Diagrams, the module map, the tech stack, and the OSS package list.
Samples →
A worked example using all four entities together.