Goooy AI Agents

A guide to Goooy’s built-in AI agents: what they are, how they work, how you keep them under control, and how to switch them on. Agents are a built-in alternative to Microsoft 365 Copilot and Google Gemini, designed so your business never has to leave your own boundary.

Goooy ships an AI agent subsystem: a catalogue of standard, department-aligned agent roles that an administrator switches on per organisation and fine-tunes. Each enabled role is provisioned as an agent-as-user, an account that behaves like a human member of the suite (it has its own mailbox, calendar, tasks, notes and chat) but signs in for no one. Agents are governed by per-department least-privilege rules, and EU data sovereignty is a first-class constraint throughout.

What an AI agent is

An agent is a role (for example “Customer service” or “IT operations”) that, once enabled, becomes a real user in your directory. It can read what flows to it, draft and send mail, post in chat, manage tasks and look colleagues up, all within the limits its role allows. It is not a single shared assistant bolted onto the side of the app: each agent is a distinct, scoped team member that operates the same apps your people do.

The standard catalogue

The built-in catalogue mirrors a mid-size company’s org chart, so the agents map onto departments you already recognise:

• Executive: CEO office
• Finance: CFO, Accounting, Business control, Procurement, Legal & compliance
• Operations: COO, Operations, Supply-chain planning, Quality management, Customer service
• Sales & marketing: CCO, Sales, Marketing, Customer success
• People: CHRO, Recruitment, Learning & development, HR operations
• IT: CIO, IT operations, Software development, Security support

Every role ships enabled at the deployment level but switched off per organisation. Nothing runs until an admin opts a role in, and each role’s remit can be fine-tuned per organisation and per individual agent.

How an agent works

An agent runs a bounded loop: it is given a clear, role-specific brief, it sees only the tools its role is allowed to use, and it works step by step until the task is done or it needs a human. Two things can start a run:

• A chat @mention. Mention an agent in a channel or direct message and it picks up the request.
• New mail. A role can be configured so that mail addressed to it starts a run.

Agents can also be run on demand from the admin tools. Built-in limits cap how many steps a run may take, how long it may run and how often triggers may fire, so cost and runaway loops are bounded. Mail from one agent never triggers another, which prevents loops.

Staying in control: governance

Control is the point, not an afterthought. Several layers work together:

• Off by default. Every role is disabled per organisation until an admin explicitly turns it on, and disabling a role instantly revokes its agents everywhere (manual runs, triggers, the scheduler and external runtimes).
• Least privilege. Each role grants only the minimal set of tools it needs. Both what the agent is shown and what it is allowed to execute are enforced, and any over-reach is refused and recorded. Because an agent acts only as its own user, it structurally cannot reach another department’s mailbox.
• Autonomy modes. Each agent runs in one of three modes:
  • Suggest: every change the agent wants to make is a proposal a person approves first.
  • Assist: low-risk actions run on their own, but high-impact ones (such as sending external mail or posting in chat) wait for approval.
  • Autonomous: the agent acts on its own, strictly within its granted scope.
• Audit. Every run and every step is recorded, including which model provider and endpoint handled it, so you can prove what ran and where.

What an agent knows about your organisation

A freshly enabled agent is a brand-new user with an empty mailbox. It does not get blanket access to your data. Instead it builds context from a few deliberate sources:

• Its own mailbox, calendar, tasks, notes and chat. It learns from what flows to it: mail addressed or copied to it, calendar invites, the channels it belongs to and its own contacts.
• The directory. It can look colleagues up in the organisation address book (hidden accounts excluded) to find who works where and how to reach them.
• A company briefing. A short, free-text company profile that an admin writes is added to every agent’s instructions: who the company is, how it is structured, its policies and its house style. This gives instant context without granting access to anyone’s data.
• A knowledge base. Curated company documents (a handbook, policies, procedures) that admins add. Agents search this material to ground their answers in your own content rather than the open internet (see below).
• Delegated mailboxes and calendars. When a person or admin explicitly shares a mailbox or calendar with an agent, the agent can read it, enforcing exactly the same sharing rules a human colleague would need. With no share, access is refused; across organisations it is impossible.

The knowledge base

Admins build a knowledge base in Admin -> AI roles -> Knowledge base by pasting a document or importing a text file from Drive. Each document is split into passages, turned into embeddings and stored, so an agent can find the most relevant passages for a question and cite your own material. Documents are stored in the Open Knowledge Format (markdown with structured front matter and cross-links), so the base is portable: admins can export the whole base as a bundle and import it elsewhere.

Some curator roles can also be granted the separate, opt-in ability to write to the knowledge base, so that durable facts an agent confirms become citable for everyone. Writing is governed like any other change: an agent without the permission cannot write at all, an agent may only correct its own entries (human-authored entries are protected), and writes flow through the same approval gate as every other action. A starter knowledge pack ships per organisation so every role has on-policy, EU and GDPR-first grounding from day one.

Your data stays in your region

Agents run on a model endpoint you choose. You can point an organisation at any EU-resident or self-hosted model and embeddings endpoint, so prompts and documents never have to leave your boundary. The choice is configuration only, with no code change, and every run records exactly which provider and endpoint handled it, for a clean sovereignty audit trail. If a provider’s credentials cannot be opened, the run fails closed rather than silently falling back to a different provider.

Agents that learn

When enabled, an agent can distil a successful piece of work into a reusable skill: a short, written procedure it can apply next time. Skills are text-only by design: they can never grant an agent new tools or wider access (those stay under admin control), and learned skills wait in review until an admin approves them. This lets agents get better at recurring work without ever widening their reach.

Turning agents on

1. Enable the agent subsystem in your deployment configuration (and the knowledge base and self-improvement features if you want them).
2. Configure a model provider for your organisation. Use an EU-resident or self-hosted endpoint to keep data in region.
3. Open Admin -> AI roles, switch on the roles you want, and set each one’s autonomy mode and fine-tuning.
4. Write a short company briefing and, optionally, add documents to the knowledge base.
5. Mention an agent in chat, or mail a trigger-enabled role, and it goes to work.

How it compares

Goooy’s agents cover the same ground as Microsoft 365 Copilot and Google Gemini: drafting, triage, lookups and routine work across mail, calendar, files and chat. The difference is where it all happens. With Goooy the agents are part of a suite you host, they run on a model endpoint you choose, they hold only the access you grant, and every action is governed and audited. You get an AI workforce without handing your business to a hyperscaler.

For the full technical design (the provider and capability layers, the data model, the runtime, the MCP surface and the governance internals), see the AI agents reference in the product source.