The Colie guide

Overview

Colie is the fastest way to automate anything reliably while staying in control. It is a command center for agents that own real work: you describe a job in plain language, and Colie turns it into an agent with the tools, the schedule, and the guardrails to run it.

There is no flow builder to wire up and no scripting to learn. The prompt is the setup, and your first agent is up and running in minutes.

An agent is not a chatbot waiting for its next message. It works across the apps you connect: it drafts and sends email, updates your CRM, files tickets, assembles reports, and moves data between systems. It runs around the clock on schedules and triggers, whether or not you are at your desk.

Three things set Colie apart:

• You stay in control. Consequential actions wait in your approval inbox, and every run leaves a full trace you can inspect step by step.
• It learns your team's knowledge. Playbooks, tone, product rules, and judgment flow into the agent, so the work comes out the way your team would do it.
• It improves every week. Colie studies its own runs, drafts improvements, and applies the ones you approve. Day one is the floor, not the ceiling.

Connections

Connections are how agents reach your tools. Colie ships with more than 3,000 integrations, so the apps your team already lives in are a couple of clicks away.

Connecting takes a minute:

1. Ask for the connection in chat, like "Connect my Gmail".
2. Sign in through the service's own secure login screen.
3. Choose which capabilities the agent gets.
4. The tools are live and the agent gets to work.

You decide how much an agent can do with each connection. Grants are granular: you can give read-only access, limit an agent to specific capabilities, and revoke anything at any time. When an agent wants to use a tool you have not approved yet, it asks first.

Credentials are encrypted and injected only at the moment a tool call runs. The model never sees your passwords, tokens, or API keys.

If a tool is not in the catalog, agents can call any HTTP API or MCP server directly, including internal ones. Hand over the docs and the credentials, and the agent figures out the rest.

Triggers & schedules

Triggers are what make an agent autonomous instead of on-demand. Set one up in plain language and the agent runs itself.

Webhooks also let agents trigger each other, so one agent's outcome can start the next agent's job. And an agent can hold several triggers at once: a weekly schedule for the report, plus a webhook for the urgent path.

Triggers are managed from the agent itself: test one, inspect what it last did, or remove it.

Prompt apps

Some work needs an interface, not a conversation. Describe the app you wish you had and Colie builds it: a live, interactive app that opens in the panel next to your chat.

Prompt apps are wired to your real data through your connections, and they are not read-only. Actions you take in the app feed back to the agent, which carries them out through the connected tools. The app persists with the agent, and if you want it changed, you just say so.

Typical uses: dashboards that stay current, trackers, review queues, and small internal tools nobody ever had time to build.

Browser

Plenty of work lives on websites with no API. Every agent has a real browser it can drive: navigating pages, filling forms, extracting data, downloading and uploading files, and working through multi-step flows.

Logins stay yours. When a site asks for a password or a CAPTCHA, you watch the browser live and take over. You sign in directly in the preview, then hand control back. The agent never sees what you typed.

Each agent keeps its own persistent browser profile, so sessions carry over between runs and you are not logging in fresh every time.

A few of the jobs teams hand to the browser:

Files & documents

Agents work with files the way they work with apps: moving them between systems, changing their shape, and producing new ones.

File work combines naturally with triggers. A single prompt like the one below becomes a job that runs itself:

MessagingComing soon

Talk to your agents the way you talk to a coworker: over email and text. Send a task from your phone, get the result back as a reply, and continue the thread to refine it.

Agents will also hold two-way conversations with people who do not use Colie at all, like sending a weekly report to a client or collecting a missing detail from a vendor, with recipients verified before any message goes out.

Approvals & control

Autonomy without control is a liability. Colie is built so that nothing consequential happens without you, and nothing it does is a mystery afterwards.

• Held actions. When a run reaches an action worth a second pair of eyes, like sending an email or changing a customer record, the agent stages it and holds. It lands in your approval inbox, where you approve it, edit it, or decline it.
• Full traces. Every run is recorded end to end: each step, each tool call, and the reasoning that connects them. When you want to know why the agent did something, the answer is one click away, in plain English.
• An audit trail that cannot be edited. The record of what ran, what was approved, and by whom is append-only. What happened is always exactly what the log says happened.

Control also means steering. If a run went sideways, tell the agent what you expected, the same way you would with a teammate. Feedback flows into the improvement loop below.

Credentials & secrets

Control extends to what agents can reach. Four rules hold everywhere:

• The model never sees your secrets. Passwords, tokens, and API keys are encrypted and injected only at the moment a tool call runs, outside the model's view.
• OAuth first.Connections use each service's own sign-in flow wherever available, with granular capability grants, including read-only.
• Revocable at any time. Every grant can be narrowed or removed the moment you change your mind.
• Browser logins stay yours. When a site needs a password or a CAPTCHA, you type it into the live preview yourself. The agent never sees the keystrokes.

The improvement loop

Most agents are as good on day one as they will ever be. Colie treats day one as a starting point. Like a new hire, it gets better every week it works for you.

Here is the loop:

• It learns on the job. Colie studies its own runs and your feedback, and picks up how your team actually works: the tone, the exceptions, the unwritten rules.
• It drafts improvements. What it learns is written down as proposed changes to its own playbook, in plain English, not buried in a model somewhere.
• You approve what sticks. Improvements apply only when you accept them. Approved knowledge is permanent: nothing resets between runs or sessions.
• Mistakes do not repeat. When something goes wrong, the slip-up is caught, explained, and turned into a fix. Once you approve the fix, that mistake is retired for good.

The result compounds. Teams typically see approval rates climb week over week as the agent internalizes more of how they work.

Organizations & roles

An organization is your company's account. It groups members, workspaces, and billing in one place, and people join by invitation.

Roles can be changed after someone joins, and admins decide who is allowed to send invites.

Workspaces

Agents get most valuable when the whole team can use them. Workspaces are how that happens.

• Personal workspaces are private. Your agents, connections, and history are yours alone.
• Shared workspaces pool agents, connections, and knowledge across the team. An agent one person defines becomes something everyone can run and build on.

Sharing has no extra step: every agent in a shared workspace is automatically available to everyone in it. Connections are pooled the same way, so a teammate's agent can act through a service you connected.

Access stays managed: workspace admins decide who joins, what gets connected, and which actions need approval. Everyone can see what ran and what came out of it, so shared agents never become a black box.

Knowledge

Knowledge is how what your team knows becomes what your agents know. It lives at the workspace level, so every agent draws from the same source of truth. There are three layers:

Agents read knowledge freely but never rewrite it on their own. When an agent believes a playbook should change, it proposes the edit through the improvement loop, and you decide whether it sticks.

Models & intelligence

Colie runs on frontier models from Anthropic (Claude), OpenAI (GPT), and Google (Gemini), and routes each task to the model that fits it. You are never locked to a single vendor, and your agents do not need rebuilding when a better model ships.

You can also set how much intelligence a job deserves. Turn it up for work that needs deep reasoning, and down for routine runs that should stay fast and cheap.

Filesystem

Each agent has persistent storage that survives across runs and sessions. It holds the files you upload, the documents the agent produces, and its working notes in between. Anything in it can be sent onward to your connected drives and apps. Like memory below, it is private to that one agent.

Code execution

Agents can write and run code in an isolated sandbox: Python 3.12 plus staples like ffmpeg, ImageMagick, Pandoc, curl, and jq, with other packages installed on demand. Useful scripts are saved, so recurring work runs the proven code instead of improvising each time.

Subagents

For big jobs, an agent does not work alone. It spins up focused subagents that fan out scraping, analysis, and batch work in parallel, then folds the results back into one outcome. You still talk to one agent, and one agent stays accountable for the job.

Memory

Each agent has its own private database for structured state: which leads it already contacted, what it has researched so far, how a long-running job is progressing. That is what lets an agent work through a list of five hundred items across many runs without losing its place or doing anything twice.

Agents use memory on their own, but if something specific must stick, just say so: