CI Academy

We start with a short demo: an assistant reads a full inbox, sorts it, drafts the replies and puts a short brief in front of you. Then you build the same thing yourself, step by step, with us.

In the first session, two hours, we explain what AI actually is, why it sometimes gets worse the longer you talk to it, and which of the tools inside ChatGPT you need for what. Then everyone opens their own mail, or our practice inbox if your company does not allow the connection yet, and hands over the first task. You read what comes back. We collect what it got wrong, an urgent mail too far down the list, a reply in the wrong tone, and each of those becomes a rule.

In the second session you write your rules down: what counts as urgent, what stays confidential, what it may never promise. You save them so the assistant keeps them, and run it again on fresh mail.

In the third session it has been running every morning on a schedule. We open the run history, find the worst run, fix it three ways, and pause and restart the schedule. Everyone does all three.

In the fourth session you pick a second task from your own job, such as confirming appointments, updating a client or checking a pipeline once a week, and build it yourself while we walk the room. If you started with the practice inbox, this is where we help you connect your own mail.

Between sessions there is nothing you must do. If you want, read one morning’s run and bring back one thing it got wrong.

You leave with the assistant running on your mail, your rules saved, a schedule you can read and stop, and a second task you built alone.

The group works on one project. The default is the inquiry project: new inquiries get sorted, checked against your criteria, answered, followed up, and passed to the colleague who takes over. It runs on our practice data, so nobody’s IT can block it.

In the first session the AI interviews you: what makes an inquiry serious, what may be promised in a first reply, who gets which handoff. You answer, we write the criteria down as rules, and we run one inquiry through the whole chain live.

Overnight it works through a batch of twenty. In the second session you judge the results, keep what is right, fix what is wrong, and split the remaining work into pieces it can finish alone. This is where Codex comes in, for the tracking file and the daily report, and we show the difference in ten minutes on the task in front of you.

In the third session you finish, schedule the daily run, and decide what it may do alone and what it must flag. Another participant receives one of your handoff summaries and says whether they could act on it without asking.

Along the way you brief it by voice from the road once, and you get it to explain a choice until you understand it, because you sign off on nothing you cannot explain yourself.

You leave with the system running on practice data, ready to point at your real mail, and with a written list of the decisions that made it good.

Module 3 connects what you built to the systems your business already runs on.

We start with the connection question: there are three ways to link AI to a customer database, a mailbox, a calendar or a portal, and we show you how to choose one for the task in front of you instead of learning all three.

Then we wire the inquiry system from module 2 into a live system with prepared data: it reads the portal, writes to the customer database and tells the responsible person. Together we decide what it may read, what it may write, what it may start on its own, and what always goes to a named person. We play through an inquiry with missing details and one that needs a colleague’s decision, and you set where those cases go.

We build one report and one alert: a weekly summary of competitors, prices or the market with sources, and an alert that fires when something needs you and stays quiet when it does not. We test a case that should trigger it and one that should leave you alone.

If the result needs a place to live, we put it on a private internal page and check who can open it.

You leave with one agent connected to a live system, the approval steps set, one alert running, and every exception going to a person.

Module 4 is for a system that has been running for a while and now handles real customers, where a mistake costs money or trust.

We take a system that has been running for a while and look at what it got wrong, what it cost, and what happened when a data source changed its format. From that you build a small set of test cases, so every change you make afterwards can be checked against the old version, including on cases that already worked.

We go through cost step by step: which AI for which task, how much effort to give it, and how to estimate the monthly bill from the number of runs you expect. The rule of thumb is simple: the vaguer the task and the more unknowns in it, the more effort it needs, and most steps need much less than people buy. We show a real case where an inbox agent cost thousands a month that should have cost a hundred.

We make some rules unbreakable, such as never sending without approval, and you try an action that must not happen and check that the system blocks it. We let a second AI from a different maker check important work before you approve it.

We move from schedules to systems that start when something happens, and we play through a failure: you restore a working version and find exactly which mails or reports need checking again.

You leave able to run a system the way a business runs one: measured, priced, guarded, and recoverable.

Module 5 takes a method one person in your firm already uses and makes it the team’s.

We set up one set of working instructions the firm owns, whichever accounts people use, and decide who may propose changes and who approves them.

Then we run one change through the whole loop with a concrete example, such as a correction to the wording of an offer: a colleague proposes it, someone reviews it, everyone receives it, nobody’s version breaks, and we roll it back to show it can be undone. You keep the record of who approved what and which version the team is on, and we check that the assistants use the new version too.

We build in the approvals that risky actions always need, and you check that another colleague cannot skip them. We show how one correction reaches every colleague and every assistant the same afternoon.

Where the firm needs it, we set up assistants that work around the clock for several people on several machines, and we look at AI on your own hardware for sensitive data and small models trained on your own data.

You leave with a method the whole team can use, review and improve, and a record that shows who changed what.

Module 5 runs on request, as a project with your firm.