Mak­ing AI Work with Work

Pow­er­ful AI is here. It will change every­thing. Yet, it has­n’t changed much. Even though AI has shown re­mark­able abil­i­ties: it can pro­duce work­ing code, deftly ma­nip­u­late spread­sheets, and con­trol com­put­ers. It has been widely adopted in white-col­lar work. Yet some­how, in the grand scheme of things, the world has­n’t changed much. Soft­ware is still buggy, and it’s hard to at­tribute eco­nomic growth to AI up­lift.

Some of this is be­cause AI is not pow­er­ful enough to trans­form every­thing yet. The na­ture of AI in­tel­li­gence is still jagged. It can solve a mil­len­nium prob­lem, cre­ate an­i­mated mu­sic videos, but can’t write this doc­u­ment to the stan­dard of qual­ity I’d want.

AI agents are ef­fec­tive and au­tonomous for tasks with ver­i­fi­able goals, which are well rep­re­sented in pop­u­lar bench­marks and learn­ing en­vi­ron­ments. They can also make rea­son­ably good de­ci­sions where the cor­rect choice is easy to check.

How­ever, I’m un­sure if pow­er­ful AI can be a drop-in re­place­ment for hu­man jobs in the near fu­ture. Jobs in­volve notic­ing what needs do­ing, de­cid­ing what mat­ters—and this in­volves get­ting ac­cess and co­op­er­a­tion (with other hu­mans) or re­call­ing con­text that may not have a con­crete record. Or­gan­i­sa­tions live through a se­ries of long-hori­zon de­ci­sions where it is not fea­si­ble to ver­ify if any par­tic­u­lar de­ci­sion was cor­rect and led to the most op­ti­mal out­come. So­ci­etal norms thus re­quire us to still have a hu­man to own these long-hori­zon out­comes. It’s hard to see an al­ter­na­tive: even in a hy­po­thet­i­cal fu­ture where an AI sys­tem is do­ing “all pos­si­ble work,” some­one has to be on the hook to align it to hu­man needs.

This is why we still need to co­ex­ist and cowork with AI sys­tems, and I posit that the cur­rent means of do­ing so are in­ef­fec­tive, which is a big rea­son for why AI has­n’t had the im­pact it could have. Most ex­ist­ing sys­tems are skeuo­morphs, “horse­less car­riages” or have a qual­ity of AI be­ing tacked on in ways that do not in­di­cate strong form-con­text fit. More­over, or­gan­i­sa­tions them­selves need to change to fit the strengths of the tech­nol­ogy.

We need to find bet­ter ways to set up sys­tems, in­ter­faces, and processes for hu­mans and AI to col­lab­o­rate and cre­ate pro­duc­tive co­evo­lu­tion­ary loops.

Here, I pre­sent a se­ries of chal­lenges rel­e­vant to mak­ing AI work well for or­gan­i­sa­tions. What does it mean to re­or­gan­ise work around agents? How do hu­mans del­e­gate and col­lab­o­rate with AI sys­tems? How can we make sense of the work pro­duced by agents? How can an or­gan­i­sa­tion learn over time from this col­lab­o­ra­tion?

Reengi­neer­ing work

In Don’t Au­to­mate, Oblit­er­ate (1990), Michael Ham­mer ar­gued that new in­no­v­a­tive tech­nolo­gies (at the time, IT sys­tems in fac­to­ries) should not be in­stalled on top of in­her­ited hand­offs and de­part­men­tal di­vi­sions. The bound­aries of work must be re­drawn around the new bot­tle­necks brought about by AI ca­pa­bil­i­ties.

The new con­straints are un­der­stand­ing the work done—and the idle time where it is wait­ing for some­one’s ap­proval. Putting an agent to work on any­thing that aren’t these bot­tle­necks will not in­crease pro­duc­tiv­ity at the or­gan­i­sa­tion level. It may even hurt it by cre­at­ing more stress on the bot­tle­neck (in the form of un­re­viewed work). If drop­ping an AI agent into a shared cha­t­room, or hand­ing every­one a Claude sub­scrip­tion did not im­prove an or­gan­i­sa­tion’s over­all pro­duc­tiv­ity, this is likely why. We need to make sure that AI is speed­ing up work that is fin­ished, and not work that is wait­ing to be fin­ished.

A pa­per by NBER pro­poses a model for rea­son­ing about how work bound­aries should change with the ad­vent of AI au­toma­tions. The unit of re­design is around the hu­man-ap­proval bot­tle­necks. In­stead of remap­ping ex­ist­ing tasks to AI agents as-is, you have to change the re­spon­si­bil­i­ties and task bound­aries based on check­points where hu­man in­put or un­der­stand­ing is needed.

So if you have an ex­ist­ing work­flow that looks like this, all done by hu­mans:

You may want to reengi­neer it to be some­thing closer to this:

All the pre­vi­ous work of fetch­ing and clean­ing the data and analysing it still hap­pens, but they are not bro­ken apart as sep­a­rate tasks, rather they are in­ter­nal op­er­a­tions to a larger unit that’s han­dled end-to-end by an AI agent. A sim­i­lar process of re­defin­ing work bound­aries for a bank ac­count rec­on­cil­i­a­tion was de­scribed by Va­suman Moza in Ap­plied AI Does­n’t Work.

There­fore, a scat­tered pep­per­ing of “AI magic dust” in sev­eral lo­calised places within an or­gan­i­sa­tion is go­ing to do lit­tle to im­prove pro­duc­tiv­ity, and nei­ther is in­dis­crim­i­nately drown­ing all ex­ist­ing processes in AI to­kens across all tasks with­out chang­ing the process. What will help how­ever, is dis­cov­ery of where hand­offs and co­or­di­na­tion hap­pens in ex­ist­ing work­flows which would al­low or­gan­i­sa­tions to reengi­neer them so that work through­put is max­imised at the con­strained points, which dic­tate the through­put of the whole sys­tem.

An ef­fec­tive mul­ti­player AI sys­tem has to be able to sur­face the true be­hav­iours and work­flows that al­low the or­gan­i­sa­tion to reengi­neer it into an “as­sem­bly line” that is amenable to con­tin­u­ous im­prove­ments and cal­i­bra­tion. This is the floor that needs to be cleared. But to get there, we need to start some­where. And a nat­ural place to start are the agents in a shared cha­t­room.

Agents in a shared cha­t­room

A shared mes­sag­ing chan­nel is a nat­ural start­ing point for col­lab­o­ra­tive work. Given the in­cli­na­tions to be a chat as­sis­tant, why not drop the AI into ex­ist­ing Slack or Teams chan­nels and re­spond to sev­eral users in the form of an agent?

Agents, in prac­tice, are of­ten a pack­aged bound­ary that as­sem­ble the fol­low­ing com­po­nents:

These agents do work, of­ten in a sand­box act­ing like its own com­puter and cre­ate ses­sions that grow (and com­pact, and fork) as users in­ter­act with them.

It’s pos­si­ble to or­gan­ise agent iden­ti­ties in sev­eral ways, de­pend­ing on how the above com­po­nents are com­posed to­gether.

The Gen­er­al­ist Chat­bot. Users have one agent iden­tity to in­ter­act with. They may or­ches­trate other agents or sub­agents and fan out tasks. In this sit­u­a­tion, the pol­icy and skills are late-bind­ing. Any kind of spe­cial­i­sa­tion for a par­tic­u­lar task or work­flow is fig­ured out af­ter the user prompts the agent. Agent ses­sions are of­ten ini­ti­ated in a chat thread by a co­or­di­na­tor agent.

Claude Tag is the poster child of this ap­proach to mul­ti­player agents. Every­one only tags an @Claude and it is up to that Claude to fig­ure out the pol­icy, skills and rel­e­vant mem­ory based on cer­tain rules.

The Swarm of Spe­cial­ists. This is akin to how hu­man roles are set up to di­vide re­spon­si­bil­i­ties in a real or­gan­i­sa­tion. These are of­ten early-bind­ing. The as­sem­bly of avail­able skills, pol­icy and state is de­fined up front, or con­fig­ured by the ven­dor and at­tached to a per­sis­tent iden­tity. There are many agents one could tag and in­voke, and agents can also talk to each other and hand off work.

Ope­nAI’s Dots, Grok Bot or Her­mes with bot mode cap­ture this form. Users set up one or more such bots, and carry with it all the con­text and work they have been do­ing.

Bring­ing agents into a cha­t­room also puts forth ques­tions about or­gan­i­sa­tional de­sign.

The early-bind­ing so­lu­tion with a swarm of agents, may be to spec­ify the roles up front and have them set up in a hi­er­ar­chy, just as we might with an or­gan­i­sa­tion of hu­mans. This could be done in a top-down man­ner, where an op­er­a­tor, with in­puts from in­di­vid­ual con­trib­u­tors, de­cides the right arrange­ment for an or­gan­i­sa­tion and every­one has to work with this arrange­ment.

An­other way to cut this is to give in­di­vid­ual users their own free­dom to set up agents and have them dis­cover use cases it­er­a­tively, and then or­gan­ise these agents into a use­ful hi­er­ar­chy. Ap­pro­pri­ate con­trols must be pre­sent to avoid pro­lif­er­a­tion and du­pli­ca­tion of agents.

There can also be late-bind­ing so­lu­tions that are more task-ori­ented. The agent fig­ures out the right or­ches­tra­tion for a par­tic­u­lar task, with min­i­mal up­front con­fig­u­ra­tion. As com­pe­ten­cies are it­er­ated over and dis­cov­ered, they could be ex­tracted into work­flows and agent skills.

All these arrange­ments make it tempt­ing to think of AI as em­ploy­ees. Are they?

Should AI be an em­ployee?

An an­thro­po­mor­phised “AI em­ployee” serves as a nat­ural and ob­vi­ous sur­face for in­ter­ac­tion. Talk­ing to an om­nipresent, un­em­bod­ied in­tel­li­gence, where the life­time of the bot is scoped to the life­time of the task, can feel alien. A bot with a name and iden­tity, in con­trast, can feel quite fa­mil­iar. An em­ployee learns your pref­er­ences and ac­cretes a strong iden­tity over time. Like any good skeuo­morph, it lets us nat­u­rally tran­si­tion our ex­ist­ing ways of work­ing into a new AI-dri­ven econ­omy. We al­ready have ex­ist­ing ways of or­gan­is­ing hu­man roles and work, and this would trans­fer to this form fac­tor.

How­ever, there are many ways pre­sent AI sys­tems do not share char­ac­ter­is­tics of an em­ployee, which may re­sult in sur­prises for users that don’t know how these har­nesses are set up.

AI agents lose co­her­ence over time, due to the ar­chi­tec­ture of the trans­former, where a model can only hold a fixed amount of to­kens in a ses­sion. Even this un­der­stand­ing de­grades as the ses­sion gets longer. To keep go­ing, agents go through a lossy com­paction process and may need to of­fload in­for­ma­tion to ex­ter­nal stor­age. Hu­mans on the other hand, gain co­her­ence over time.

For so­phis­ti­cated agents, AI en­gi­neers of­ten set up prod­uct eval­u­a­tions where they con­tin­u­ously col­lect co­pi­ous amounts of its traces and ac­tiv­ity, ob­serve agent be­hav­iours and cal­i­brate them to match the prod­uct goals and or­gan­i­sa­tion’s ob­jec­tives. These evals can then catch when they drift over time and steer the agent back to the right be­hav­iour. You won’t quite work with an em­ployee in this way.

Your coworker does­n’t have to re­trieve “skills,” or a folder of in­struc­tions teach­ing spe­cific work­flows. You won’t see them for­get to “re­trieve a skill” and thus fail to ad­here to a spe­cific work­flow.

There’s a ma­jor rift in re­call when some in­for­ma­tion is within the con­text win­dow ver­sus when it is out­side it, and be­hind a bot per­sona, it can be hard to tell what is in the con­text of the agent. You have to de­scribe tasks dif­fer­ently than you would with a hu­man, and re­peat­edly spec­ify con­straints in a way spe­cific to work­ing with agents.

Ad­di­tion­ally, hu­man roles come with ac­count­abil­ity. Peo­ple have their rep­u­ta­tions to pro­tect, and so­cial con­tracts to ful­fil. An AI does not have this. In my use, AI agents of­ten make mis­takes or per­form in ways that would have re­sulted in an equiv­a­lent hu­man get­ting fired. But we keep them be­cause they are use­ful in ways hu­mans are not.

The an­thro­po­mor­phis­ing form fac­tor can also mask cer­tain abil­i­ties that agents have. Un­like hu­mans, they can fork a clone of them­selves con­tain­ing the same con­text, or­ches­trate other agents, work around the clock with­out get­ting tired, and churn out code at su­per­hu­man speeds. Every bot is equally ca­pa­ble (given the same model) and thus seg­re­gat­ing them into the roles amounts to a cer­tain con­strain­ing of its abil­i­ties, to fit into the di­vi­sion of roles that hu­mans have. To­day’s agents are not great at co­or­di­nat­ing with each other, but they do not have the lim­i­ta­tions that hu­mans have when it comes to hand­ing off work. This can open up new ways of work­ing.

AI em­ploy­ees make sense as a form fac­tor, but good in­ter­faces for them should help users in­spect and un­der­stand all the ways in which they are not like their hu­man coun­ter­parts. Not only must the em­ploy­ee’s ca­pa­bil­i­ties be leg­i­ble, so must the large vol­umes of work they pro­duce. Be­cause un­der­stand­ing is a huge bot­tle­neck.

Un­der­stand­ing is the bot­tle­neck

Most knowl­edge work will in­volve the cre­ation of shared arte­facts: doc­u­ments, spread­sheets, dash­boards and re­ports, to name a few. These arte­facts are most use­ful as tools to aid com­plex prob­lem solv­ing by be­ing an ex­ten­sion of hu­man’s work­ing mem­ory, pro­vid­ing a lens to ex­plain the state of the world, and help with ac­count­abil­ity and au­dits.

What are the op­por­tu­ni­ties in a world where AI is heav­ily in­volved in the cre­ation and pro­duc­tion of these arte­facts?

AI agents can cre­ate a lot of large arte­facts quickly, which cre­ates a bot­tle­neck: the un­der­stand­ing and com­pre­hen­sion of its work. Ge­of­frey Litt ar­gues that un­der­stand­ing the work pro­duced is a pre­req­ui­site for hu­mans to come up with the next idea to evolve the sys­tem, and en­sure their con­tin­ued par­tic­i­pa­tion.

There are many di­men­sions to con­sider when we are try­ing to cre­ate a shared un­der­stand­ing that helps or­gan­i­sa­tions come up with the next idea. Not every­one needs to un­der­stand every­thing that agents do. Each per­son needs a view into the work that gives just the right amount of in­for­ma­tion that is rel­e­vant to them.

To­day, we need to find the right trade­off be­tween the speed of pro­duc­tion from agents and the fric­tion of un­der­stand­ing the work so as to fig­ure out what needs to be done over a long hori­zon of time.

Bring­ing hu­mans into the agent ses­sion

Pre­vi­ously, we could rely on knowl­edge work­ers to have a good men­tal model and deep un­der­stand­ing of what they are work­ing on be­cause pro­duc­ing the work it­self re­quires the nec­es­sary fric­tion that pro­duces a deep un­der­stand­ing of work.

Cha­t­room agents by­pass this mech­a­nism. They are an in­stru­men­tal ap­proach, where hu­mans are fo­cused on a spe­cific goal, and it only mat­ters that the goal is met while re­spect­ing any rel­e­vant con­straints.

While a cha­t­room agent can link to or open up the prod­uct of their work, it still ob­scures de­tails of the agen­t’s think­ing and process. This is a loose feed­back loop.

A more en­gaged ap­proach could be to bring mul­ti­ple users as par­tic­i­pants within an AI agen­t’s ses­sion, rather than have an agent par­tic­i­pate in a hu­man’s cha­t­room. This is the ap­proach taken by Zed’s Delta and (to a lesser ex­tent) Am­p’s mul­ti­player mode.

In this ap­proach, all com­ments and con­ver­sa­tions from all the par­tic­i­pants are in­ter­leaved into the agen­t’s ses­sion and con­text win­dow. This al­lows for more fine-grained steer­ing that is more suit­able for tasks where some ex­plo­ration is needed. This deeper en­gage­ment with the users also helps build un­der­stand­ing of the sys­tem with all the users in­volved, which re­duces cog­ni­tive debt.

Whether a task needs this in­ver­sion is a mat­ter of taste. Of­ten, work that is on the edge of an AIs abil­i­ties, or work that is hard to ver­ify, or work that is cru­cial to be deeply un­der­stood would ben­e­fit from this ap­proach.

There re­mains a lot of work where the goals and out­comes mat­ter far more than the de­tails over a long hori­zon, where a lit­tle more speed will di­rectly ben­e­fit the or­gan­i­sa­tion. For this, we con­sider col­lab­o­ra­tive, shared, and dy­namic arte­facts.

Re­al­time col­lab­o­ra­tion on shared arte­facts

Arte­facts such as doc­u­ments, slides and spread­sheets in an or­gan­i­sa­tion are the lenses through which var­i­ous peo­ple get the right in­for­ma­tion and un­der­stand­ing at the right level. To be able to work on them col­lec­tively helps build a shared un­der­stand­ing.

We al­ready have tools that en­able re­al­time mul­ti­player edit­ing of arte­facts be­tween hu­mans. AI agents open up many op­por­tu­ni­ties for im­prov­ing the qual­ity and pro­duc­tiv­ity of work, and also brings new de­sign con­sid­er­a­tions along with it. Most im­ple­men­ta­tions fo­cus on sum­mari­sa­tion and un­der­pow­ered in­for­ma­tion re­trieval, which do not fully ex­ploit the in­her­ent ca­pa­bil­i­ties of AI mod­els.

A first step, one that is in­creas­ingly com­mon­place, is to have the agent be a par­tic­i­pant in mul­ti­player text can­vases. Tools like Au­tomerge, Yjs and Patch­work demon­strate ways to im­prove the ver­sion con­trol ex­pe­ri­ence, which are im­por­tant in the face of in­creas­ing ve­loc­ity of changes brought about by AI agents.

How­ever, most real world work to­day ex­ists in the form of doc­u­ments from ex­ter­nal sys­tems and sources, of­ten in pro­pri­etary for­mats or locked up in ex­ter­nal SaaS tools. There­fore, hav­ing in­ter­nal can­vases will never be suf­fi­cient—a good shared arte­facts im­ple­men­ta­tion must be able to pro­vide a solid ecosys­tem of con­nec­tors to ex­ter­nal ser­vices, and cre­ate adapters for the data re­trieved from these ex­ter­nal ser­vices.

And then, be­cause an agent is tire­less, we should make it do a lot more work in help­ing us deeply un­der­stand what it has done, at a level be­yond rea­son­able to ask of a hu­man.

Dy­namic arte­facts

Our doc­u­ments and arte­facts can be a dy­namic medium.

In-house im­ple­men­ta­tions of col­lab­o­ra­tive doc­u­ments and can­vases al­low for bet­ter ex­pe­ri­ences in the form of mal­leable soft­ware, or soft­ware that can mod­ify it­self to fit the im­me­di­ate needs of the en­vi­ron­ment and busi­ness con­text . Cloud­flare OS uses gadgets, which are code-based arte­facts which al­lows for greater con­trol and guar­an­tees over the se­cu­rity and ac­cess poli­cies.

AI greatly re­duces the fric­tion in­volved to write pro­gram­matic scripts that can re­trieve and crunch data on re­quest, and vi­su­alise it in use­ful ways. A use­ful pat­tern is to lever­age this medium to cre­ate rich in­ter­faces to help ex­plain and vi­su­alise the state of the world in an in­ter­ac­tive way, which helps bring hu­mans back in the loop for un­der­stand­ing and com­pre­hend­ing the work. Mag­gie Ap­ple­ton of GitHub Next uses the idea of “bound­ary ob­jects” to cre­ate arte­facts that help re­duce the cog­ni­tive over­head of read­ing large ver­bose walls of text.

A good bound­ary ob­ject is­n’t nec­es­sar­ily about hav­ing great vi­su­als. It must pull all the levers that help fa­cil­i­tate un­der­stand­ing. A lot of “gen­er­a­tive UI” ef­forts fail at this step.

So what makes a good dy­namic medium for un­der­stand­ing?

First, they must be high band­width. We do not re­ject prose, but we think it can be well-sup­ported by high-band­width vi­su­al­i­sa­tions, such as charts and ta­bles.

Sec­ond, they must fa­cil­i­tate ef­fort­ful re­trieval. Most arte­facts to­day con­vey un­der­stand­ing via read­ing. Un­for­tu­nately, read­ing does not work too well—it of­ten gives some­one the il­lu­sion of learn­ing. True learn­ing hap­pens through feed­back loops, where a user’s un­der­stand­ing is tested and mea­sured against the ground truth. There’s a fine line to con­sider here. Forc­ing every doc­u­ment to have a quiz can get frus­trat­ing. This is pre­cisely where in­ter­ac­tiv­ity can be help­ful. It cre­ates a feed­back loop that re­solves a per­son’s pro­jected pre­dic­tion with the ac­tual work­ing of a sys­tem.

They must also be flex­i­ble and multi-di­men­sional. The pro­gram­mer’s con­cerns are dif­fer­ent from a prod­uct man­ager’s con­cerns are dif­fer­ent from the sales an­a­lysts’ con­cerns. A dy­namic arte­fact can pull from the same ground truth and show every­one the view that they need to un­der­stand, and en­able them to re­lent­lessly zoom in and out the var­i­ous lev­els of de­tail. Lan­guage mod­els can fa­cil­i­tate this.

The ef­fec­tive­ness of a col­lab­o­ra­tive, shared, and dy­namic arte­fact re­lies on the ef­fec­tive­ness of the ground truth that it de­rives from, and this is the mem­ory and knowl­edge within an or­gan­i­sa­tion.

Or­gan­i­sa­tional Mem­ory

Let’s take a broader view of mem­ory—forms other than facts in an in­for­ma­tion sys­tem. Walsh and Ung­son’s sem­i­nal work on or­gan­i­sa­tional mem­ory notes that mem­ory re­sides in many places like,

• peo­ple’s heads
• or­gan­i­sa­tion cul­ture
• the processes that trans­form or­gan­i­sa­tions
• so­cial struc­tures and role hi­er­ar­chies
• the broader ecol­ogy and phys­i­cal spaces
• the world out­side the or­gan­i­sa­tion, eg: what the com­pe­ti­tion did

We can think of mem­ory cap­tur­ing a par­tic­u­lar stim­u­lus (what hap­pened) and a re­sponse (how we dealt with it). So­cial struc­tures and ecolo­gies can of­ten tend to only store the re­sponse with­out the stim­u­lus. Trans­for­ma­tional processes can store the who, what, when, where and how with­out the why. Not all of this is con­scious. Some of these buck­ets con­sti­tute fast au­to­matic re­trievals of mem­ory rather than de­lib­er­ate ef­fort­ful re­trieval.

An ef­fec­tive AI sys­tem must con­sider all these forms of mem­ory. It must pro­vide means to mod­ify mem­o­ries be­yond facts, by al­low­ing or­gan­i­sa­tions to dis­till learn­ings from past processes, re­de­fine work bound­aries, ex­tract “tribal knowl­edge” from peo­ple, and re­shape an or­gan­i­sa­tion’s cul­ture.

The ex­trac­tion of knowl­edge re­quired for this broader and ef­fec­tive use of mem­ory re­quires an em­pha­sis on ex­pe­ri­en­tial mem­ory rather than a mere fact-based mem­ory. The pro­cess­ing of agent traces and in­ter­ac­tions at or­gan­i­sa­tional bot­tle­neck points, for ex­am­ple, can help point to im­proved processes that help in­crease pro­duc­tiv­ity.

We also can­not as­sume that the re­trieval of mem­ory al­ways im­proves the ef­fec­tive­ness of de­ci­sions. How a mem­ory is in­serted, man­aged and re­trieved is im­por­tant. Old prece­dents mis­ap­plied to novel sit­u­a­tions can lead to mis­guided de­ci­sions or com­pla­cency that stag­nates progress.

Cer­tain kinds of “re­mem­ber­ing” are ex­plicit and re­quire a de­lib­er­ate lookup like facts in a data­base, or work in a task tracker. But other forms of mem­ory are im­plicit and “au­to­matic,” like the pro­ce­dures and work­flows in an or­gan­i­sa­tion, cul­ture, and ecol­ogy.

Thus, AI sys­tems must also pay at­ten­tion to what it chooses to for­get over time. It is not enough to clear up old and stale mem­o­ries, but an up­date on new stim­uli must also con­sider the “au­to­matic” re­trievals. A new set of facts retro­fit­ted on old processes may not lead to ef­fec­tive for­get­ting or up­dates of an or­gan­i­sa­tion’s mem­ory. It will only re­call newer facts through path­ways that em­bed older ways of work­ing.

An AI sys­tem must thus not just merely “re­mem­ber” a fact, but take on an ac­tive role in help­ing sort through old knowl­edge in the or­gan­i­sa­tion and help hu­man col­lab­o­ra­tors un­der­stand the ap­pro­pri­ate­ness of a re­mem­bered fact. It must also pro­vide a sys­tems view of the or­gan­i­sa­tion so to fa­cil­i­tate the cor­rect kind of mem­ory up­date and cleanup.

Dis­till­ing knowl­edge

Every or­gan­i­sa­tion leaves be­hind a whole bunch of traces. Agent traces make a large chunk of an or­gan­i­sa­tion’s mem­ory ob­serv­able in great de­tail. In the be­fore-times, you of­ten only had the in­puts, the out­puts and what­ever it is that you kept in a sys­tem of record. With agents en­ter­ing the work­place, you have a log of thou­sands of in­ter­ac­tions that open up the processes of an or­gan­i­sa­tion, of­ten in the form of a ne­go­ti­a­tion be­tween the em­ploy­ees and the agents.

We could not have this kind of in­for­ma­tion be­fore. It was sim­ply too high-fric­tion to tem­po­rally log all the three ap­proaches tried and thrown away when re­solv­ing an is­sue or pro­duc­ing an out­come. But agents have made it such that traces are formed as byprod­ucts of get­ting the work done. It just so hap­pens that the “byprod­ucts” here are gold. It dou­bly helps that AI is good at deal­ing with the vol­ume of traces that are pro­duced by AI.

Why are traces valu­able? Be­cause they en­able the dis­til­la­tion of knowl­edge, ie, tak­ing a messy, noisy set of processes, and ex­tract­ing only the truest essence of it, thus mak­ing them more leg­i­ble and ef­fi­cient. With the work be­ing more gran­u­larly vis­i­ble in the agent traces, it is pos­si­ble to catch in­ef­fi­cien­cies and re­or­gan­ise work to elim­i­nate them.

The dis­til­la­tion of knowl­edge can take many forms. They can be used for en­cod­ing skills for the agents to use, ex­tract the processes for other hu­mans, and help ex­plain prece­dents and pro­vide the “why” for processes that are “au­to­mat­i­cally” re­trieved.

Even­tu­ally the dis­tilled knowl­edge also forms the ba­sis for an in­de­pen­dent and ro­bust AI stack within an or­gan­i­sa­tion. It al­lows one to re­duce de­pen­dence on a spe­cific AI ven­dor as the ma­chin­ery to re­fit a new ven­dor can be de­rived from these traces.

Rais­ing the Bar

AI mod­els are ex­po­nen­tially im­prov­ing, yet the road ahead for trans­form­ing the world with it is long. We need to raise our bar to make this an ef­fec­tive tech­nol­ogy. This means start­ing from re­ex­am­in­ing how we do our work to fit AI sys­tems, then re­ex­am­in­ing how we build our AI sys­tems to fit our work, and then think­ing of ways to open up our un­der­stand­ing of the work they pro­duce, and in­cor­po­rate that to make our or­gan­i­sa­tions even more ef­fec­tive. This forms the core outer loop.

Each chal­lenge de­scribed here con­tains frac­tal mul­ti­tudes of sub­prob­lems that we need to tackle to make AI ef­fec­tive in the work­place, and ul­ti­mately for tech­no­log­i­cal progress and growth.

Cur­rent AI sys­tems have barely scratched the sur­face, and I re­main op­ti­mistic that we can evolve our so­lu­tions to serve us a lot bet­ter.