Osysharp.Agents.Management — the place a person runs an app's agents from

`Osysharp.Agents.Management` is eight screens under one path: every agent with who answers for it; one agent; all the work; one piece of work; everybody the agents are waiting on; the standing rules; spending; and who may do what.

You are here: Building with agents › The kits › Agents.Management

Summary#

Osysharp.Agents.Management is eight screens under one path: every agent with who answers for it; one agent; all the work; one piece of work; everybody the agents are waiting on; the standing rules; spending; and who may do what.

From them a person in charge pauses an agent and lets it work again, calls a piece of work off, tries it again, or hands it to a person. Every figure is read from the records. The screens decide nothing: each control is offered only to somebody the core kit's policies admit.


Package	`Osysharp.Agents.Management`, version 1.2.0
You add it with	`use Osysharp.Agents.Management;` in the app's manifest.
It sits on	[[agent-kit-agents\|Agents]], [[agent-kit-agents-human-requests\|Agents.HumanRequests]], [[agent-kit-agents-inspector\|Agents.Inspector]], [[agent-kit-agents-teaching\|Agents.Teaching]], [[agent-kit-human-requests\|HumanRequests]], [[agent-kit-llm\|Llm]], [[agent-kit-work-queues\|WorkQueues]]
It also uses	`Identity`, `Ui` — parts of the platform's own library
Its own test app	A film archive that takes reels into its collection with the help of five agents — `kits/agents-management/tests`

Description#

What do you get without writing anything?#

Three routes mount all eight screens.
Each person sees what is theirs: the head of a team everything, a bookkeeper every figure and no words, a colleague the work they asked for.
Where a proposal went — to a person or to a queue — is said on the screen.
On the inspector's page, the controls of whoever is in charge sit at the top.

When do you need it?#

When an app has more than one or two agents, or people other than the developer are in charge of them.

What does it expose?#

The tables below are generated from the kit itself, not written by hand: osy kits Osysharp.Agents.Management --surface lists each of them with the code of the kit's own test app that uses it, and the tests that show it working.

Functions you call, those its own tests show most first.

Function	What it does	Tests that show it
`Money(long micros)`	A sum in millionths of a dollar, as money.	8
`RosterOf()`	Every agent of the app, for the roster: who answers for it, whether it is working, what it has under way, what it has spent and how often people corrected it — counted over the work whoever is lo…	7
`AgentProfileOf(string agent)`	One agent, for its own page — as whoever is looking may read it.	7
`PeopleAdmittedTo(string policy)`	The people one policy admits, by name — asked for one policy at a time, when somebody wants to know.	7
`RulesBoardOf()`	Every standing rule, as whoever is looking may read it — and what a rule could still change.	6
`TakeBackRule(Guid rule, string why)`	Take a standing rule back from the screen, with the reason.	6
`AllowAloneFromManagement(string agent, string action, string skill, bool forEverybody)`	Say "from now on, alone" from the screen: for the work the agent does for whoever says it, or — `forEverybody` — for anybody.	6
`RolesBoardOf()`	Who may do what — every policy about the app's agents, and whether it admits whoever is looking.	6
`SpendingBoardOf(string period = …)`	What the agents' work cost in a period — by the work that started in it — as whoever is looking may read it.	6
`WaitingBoardOf()`	Everybody the agents are waiting on — every open request an agent put, oldest first, and the same counted by person.	6
`WorkBoardOf(WorkFilter filter)`	The agents' work, newest first, as whoever is looking may read it — narrowed where it is stored.	6
`WorkControlsOf(Guid task)`	What whoever is looking may do to a piece of work.	2
`HandWorkToPerson(Guid task, Guid person, string note)`	Hand a piece of work to a person: the agent's work is called off where it stands — when it is still under way — and the person is asked to take it from here, in their inbox, with the note and how…	1
`StopWorkFromManagement(Guid task, string why)`	Call a piece of work off from its page, with the reason.	1

Screens and components you mount — each is one line in a page of yours.

Component	What it draws
`AgentRoster(at)`	Every agent of the app: who answers for it, whether it is working, what it has under way, what it has spent against what it may, and how often people corrected it.
`RosterRow(line, at, first)`	One agent on the roster.
`AgentProfilePage(agent, at, request)`	One agent, in full: who it acts as and who answers for it, what it does alone and what it proposes, its skills and the agents it hands work to, what it is told, what it may spend and has, its work, and every time somebody paused it or let it work again.
`ToolGroup(title, means, tools)`	One group of an agent's tools, under what its declaration says of them.
`RunField(field, typed)`	One thing a skill takes, as the Run form asks for it: a line of text, a number, or a yes or no.
`PeopleAgentsWaitOn(at, request)`	Everybody the agents are waiting on: each person with how many requests they hold and how long the oldest has waited, then every request — what is asked, by which agent, about what, since when, and whether it is late.
`AgentStandingRules(at)`	What agents do alone because a person said so: every standing rule with who gave it, for whose work, how often it has let a tool run and when it last did — and Take back, for whoever gave it or supervises.
`AgentSpending(at)`	What the agents' work cost: in all, and by agent, skill, person and what it was charged to; every limit with what the meter has counted against it; and the work a limit stopped.
`Breakdown(title, lines, at)`	One breakdown: a line a key, the largest first, each with a bar for its share of the largest.
`RoleRow(policy, kit, admits, untilSaid, you, mayAskWho)`	One policy on the Roles screen: its name, the kit that declares it, what it admits somebody to, who it admits until the app says otherwise, and whether it admits whoever is looking.
`AgentRoles(at)`	Who may do what: every policy about the app's agents — being in charge, the two that are never implied, and the kits beside — with what each admits, who it admits until the app says otherwise, and whether it admits whoever is looking; then each agent with who answers for it.
`AgentLink(agent, at)`	Every management screen, under one path.
`ManagementStrip(section, at)`	The strip that moves between the screens.
`FactOf(name, value)`	A fact with its name over it — "Started" over "5 May 2031, 08:00".
`ListSkeleton(label)`	A screen while it loads: its heading's line, then lines in the shape of a list.
`WorkRow(line, at, first, showAgent)`	A line of work, as every list of work shows it: what it is about, who is doing what for whom, when, what it cost, and where it stands.
`AgentWorkList(at, agent)`	All the agents' work, newest first, as whoever is looking may read it.
`AgentWorkDetail(task, at, request)`	One piece of work: everything the inspector reads of it — what was asked, by whom and for whom, each step, the work it handed on, what it cost, whether its record checks — then what teaching adds, and, for whoever is in charge of it, calling it off, trying it again and handing it to a person.
`WorkControlsOnTheInspector(task)`	What a person in charge does to a piece of work, added at the head of the inspector wherever the app draws one.
`WorkInCharge(task)`	In charge of a piece of work: call it off, try it again, hand it to a person — each offered only to whoever may, each with its reason, and each refusal said in the kit's own words.

Slots you can fill — a place on the kit's screens where your app, or another kit, adds a section.

Slot	What goes there
`AgentRolesBeside()`	More roles, from the kits beside — a kit or an app that has a policy about agents of its own adds its line to the Roles screen: `[Contribution("Process roles")] component ProcessRoles() : AgentRo…

Go deeper#

The management screens — where a person runs an app's agents (Agents.Management kit) — the eight screens and what can be done from them
Who is in charge of an app's agents — every policy in one table, pausing, sponsoring, and trying work again — who may do what, pausing, sponsoring, trying work again