SK Telecom now runs its in-house AI agents much as it runs staff: each one gets an employee ID, a named supervisor, scoped permissions and a performance review, and each one can be stopped. That pattern is useful well beyond a large telecom. Any company putting agents into real work needs the same four records (identity, owner, permissions and a run trace) and one check that enforces them on every tool call. This article covers both, with a short sketch of the check.

What SK Telecom published

SK Telecom published its first "AI Governance Report" on October 26, according to the Seoul Economic Daily and Financial News. Both outlets published English versions translated from Korean, so the quotes below are as those outlets translated them.

The Seoul Economic Daily reported that the company "assigns employee ID numbers to AI agents as it does to human staff, and continuously monitors each agent's role, designated supervisor, operating status and performance." Financial News described the process: once an agent has been developed, "its basic information is registered, and an employee ID is assigned to agents that meet internal standards in a separate review."

Oversight scales with risk. Financial News reported that agents which assist one person's individual tasks can be managed by that person, while agents with greater impact or autonomy are supervised by the person responsible for the work, such as a team leader or executive:

"The functions an agent can use and the data it can access are also set according to the nature of its work. The greater its autonomy, the more stringent the human review and approval procedures."

While agents run, an internal "Agent OS" records "execution status, usage and change history," and "the AI models and tools used by an agent, as well as the process by which it performs tasks, are also recorded so that the cause can be identified if a problem arises." If an anomaly occurs, "the agent's execution can be stopped." Agents are then evaluated on their operating performance and kept, improved or shut down, and SK Telecom says it will consider reflecting the results in organizational KPIs over the longer term. Financial News reports a phased plan: the foundation in 2026, stronger controls based on autonomy and impact in 2027, and a system covering agents through to decommissioning by 2028.

The gap in most agent builds

Most teams ship an agent the way they ship a script: an API key in an environment variable, a prompt, a few tools, and a chat channel where someone notices when it misbehaves. That holds up for one agent. By the fifth, nobody can say which agent wrote to the CRM last night, who allowed it to, or which model it was running at the time.

SK Telecom's answer comes with review boards and a three-year plan. The engineering underneath is small enough for any team running agents on real data.

Four records every agent needs

  1. Identity. A stable id per agent, separate from any person's account, so its actions in logs and audit trails are attributed to the agent and not to whoever set it up.
  2. An owner. A named person who answers for it, chosen by impact: the user for a personal helper, a team lead for anything that writes to shared systems or talks to customers.
  3. Permissions by autonomy. The tools it may call and the data it may read, listed explicitly, with a person's approval required on the actions that are hard to undo.
  4. A run trace. For every run: the model and its version, the prompt version, each tool call with its input and result, and the cost. This is what answers "why did it do that?" a week later.

One check on every tool call

Records only help if something enforces them. Here is a sketch of how we would do it in TypeScript. Every tool call an agent makes passes through one function that reads the registry, asks the owner where approval is required, honours the off switch and writes the trace.

// agents.ts: every tool call an agent makes goes through act().
interface AgentRecord {
  id: string;               // e.g. 'agent-invoice-chaser'
  owner: string;            // the person who answers for it
  status: 'active' | 'paused' | 'retired';
  tools: string[];          // what it may call
  needsApproval: string[];  // calls its owner must approve first
}

export async function act(agentId: string, tool: string, input: unknown) {
  const agent: AgentRecord | undefined = await registry.get(agentId);
  if (agent?.status !== 'active') throw new Error(`${agentId} is not active`);
  if (!agent.tools.includes(tool)) throw new Error(`${agentId} may not call ${tool}`);

  if (agent.needsApproval.includes(tool)) {
    const approved = await approvals.ask(agent.owner, { agentId, tool, input });
    if (!approved) return { skipped: 'not approved' };
  }

  const started = Date.now();
  const result = await tools[tool](input);
  await trace.write({ agentId, tool, input, result, ms: Date.now() - started });
  return result;
}

Three details carry the weight. The off switch is a status in a database, so pausing an agent is one update that takes effect on its next call. Permissions are checked in code outside the model, so a prompt injection or a bad plan can't talk its way past them. And the trace is written by the same function that makes the call, so the record matches what actually happened.

Review agents, and retire them

The part most teams skip is the end of the lifecycle. SK Telecom evaluates each agent and decides whether to keep, improve or shut it down. Agents pile up the same way old scripts and API keys do, and a trace makes the review cheap: per agent, how many runs last month, how many finished, how often a person had to step in, and what they cost. Our view is that an agent nobody has used in a month should be retired, with its keys revoked in the same change.

Where this is overkill

A registry, an approval queue and a trace store are three more things to build and run. For a single internal agent that only reads data and drafts text for a person to send, a named owner and one log line per run are enough. The full check earns its place once an agent writes to shared systems, touches customer data or spends money, and once there is more than one of them.

Approvals also cost time. Put them on the actions that are hard to undo, such as sending, paying or deleting. If every call needs a click, people learn to approve without reading.

Summary

  • SK Telecom gives each in-house agent an employee ID, a supervisor matched to its impact, scoped permissions, a run record and a performance review, according to the Seoul Economic Daily and Financial News.
  • The same pattern works at startup scale: identity, owner, permissions and a run trace for every agent, enforced by one check on every tool call.
  • Start by listing every agent you run today and who owns each one. The ones without an owner are the first to fix.

If you're putting agents into real work and want a second pair of eyes on how they're controlled, book a conversation.

Sources