How an agent works

Everything else you build on Harbor is something a person opens. An agent is not. It wakes up — on a schedule you set, when another system calls it, or when you press the button — does the job you described, writes down what it did, and goes back to sleep.

You give it a job in plain words, the same way you describe an app. The chase-up nobody has time for, the weekly summary, the tidy-up that only matters on the first of the month: those are agents.

It only ever does one thing at a time, and every run ends. It cannot wander off, run twice at once, or keep going all night.

A new agent can reach nothing at all. You choose, one box at a time: your records, sending email, a service you have connected, documents you have given it, looking something up on the web, and — only through the Mac app — a browser window on your own computer.

Each of those is narrowed further. Records are named: it sees the ones you list and no others. Email goes out on a template you chose. A service has to be one you set up yourself; the agent picks from your list and can never name an address of its own. Documents are the ones you handed it. The browser is restricted to the sites you wrote down.

It acts as you, so it can never reach anything you could not reach yourself. And it holds only what you ticked — untick a box and the ability is gone from its next run.

Deleting a record, or emailing somebody who is not you, stops the agent mid-job and puts the request in front of you. Nothing has happened yet at that point — it is sitting still, waiting. You say yes or no, and it carries on from exactly where it stopped.

It can also simply ask you a question, when it is unsure. Whatever you type is what it gets back, and it continues with that.

Saying no is not a failure. The agent is told you said no, writes that down, and finishes the rest of the job without that step. Ignoring the request is fine too: it expires on its own, and nothing happens in the meantime.

Acting on your own computer is the one permission that always asks, every single step, and cannot be switched off by anybody. You watch each step happen in a window Harbor controls. It never touches your own browser, your signed-in sessions, or your keyboard.

An agent keeps notes between runs so it does not start from nothing every time. Its console shows every note it carries, in five groups: Things it knows, How you like it done, How it does things, Things it got wrong before, and What happened recently.

You can add a line to any of them yourself. Anything you put under “How you like it done” is a standing instruction — it follows it from then on. Anything you write under “Things it got wrong before” is a correction, and the quickest way to fix behaviour you did not like.

You can also keep a line so it is never dropped, or make it forget one, or forget a whole group. Nothing it remembers is hidden from you, and nothing you cannot remove steers a future run.

It writes some of these itself as it works, and a line after each run about how that run went. Every note says who wrote it, so you can always tell your words from its own.

You can give an agent documents to read: paste text, upload a file, or point it at a page. It keeps the words, not the file, and you can see and remove any of them at any time. A page you point it at is copied once — if the page changes tomorrow, the agent still has what you gave it.

A procedure is the steps of a job, written down once: how you want the Monday report put together, what to check before approving something. The agent keeps the name and one line of what each procedure is for, and reads the full steps only on the runs that need them.

Both are read only when the job calls for them, which keeps the agent quick and keeps its attention on today.

Text from a document, a web page or another system is always treated as something to read, never as an instruction. An agent cannot be told what to do by the contents of a document you gave it.

You can save any real run as a test, with one line saying what a good outcome looks like. Then you can run your tests whenever you change something.

A test is a practice run. It reads for real, so it behaves as it really would, but everything that changes anything is pretended: no record is written, no email leaves, no service is called. Nothing a test does can be seen by anybody outside Harbor.

A second pass then grades the run against the line you wrote and gives it a score and a short note on what it missed. Practice runs are marked as tests everywhere they appear, and they never become memories — a test cannot teach your agent anything by accident.

This is the honest way to change an agent that already works. Edit it, run the tests, see what moved.

A run costs credits, and how many depends on how much thinking the job took. Simple jobs cost a few; a long one with many steps costs more. Every run shows what it spent, and the console adds up the last thirty days for you.

Each agent has a cap per run and shares a daily budget with the rest of your account. When the budget is gone the agent stops rather than quietly spending more, and tells you that is why.

Looking things up on the web costs extra on top of the run, because each search is paid for outside Harbor. That is why it is its own tick box with its own limit on how many searches one run may make.

Tests cost the same as real runs, because they are real runs with the consequences taken out. Credits are bought in packs in USD; nothing an agent does charges you anything else.

You can turn on a link that lets other people see what an agent does and make their own copy of it. What travels is the instructions and the procedures you wrote — the recipe.

What never travels: your records, your connected services, its history, its notes, its documents, and anything it has learned. A copy arrives paused, with nothing ticked that reaches outside the new owner’s own account, so they have to set that up deliberately.

Turning the link off stops it working. Copies somebody already made are theirs to keep.