How Swfte builds with Cortex / Approvals and governance

What stays under human approval, and how approvals work

The rule that an agent proposes and a person decides, how approvals work in Cortex, Nexus and workflows, which decisions Swfte keeps for its owner, and what is not built yet.

Approvals in the platform exist in several places, not in one. This page walks through each one that is built, says which decisions Swfte reserves to a person, and lists what is still design intent, including a single approval inbox and enforced separation between the person who asks and the person who approves. Every practice carries a label: in use, built, or designed for.

The rule: an agent proposes, a person decides

The rule is short. An agent may read, analyse, draft and propose. A person decides whether anything consequential happens. Sending, paying, deleting, pushing code and running shell commands are the usual examples. The rule is only useful if it is built into the way the system works, rather than left to a prompt that says please ask first. A prompt can be ignored. A call that cannot proceed without a recorded decision cannot.

The rest of this page shows where that is true in the platform today and where it is not. Approvals exist in several parts of the platform: in Cortex, in Nexus, in workflows and in the policy engine. They were built at different times, and they do not share one model or one inbox. We say that because a reader planning a governed rollout should know it before they start.

Five places approvals live today

All five are built in the product. None of these descriptions says Swfte runs them on its own work.

  • In-app approvals in Cortex

    When a tool call needs a decision, the approval is bound to that exact call, can be used once, and is issued by the app's main process, so the interface layer cannot mint one. Approvals and outbound-data decisions are written to an audit log chained by hash, which records metadata only.

  • Nexus approval cards

    A call held by Nexus appears as a card in the chat. The first decision wins. The decider is stamped from the signed-in person rather than typed in, and a card that nobody answers expires. An expired card does not approve the call.

  • Workflow gates

    A human input step pauses a workflow run and waits for a named assignee. It has an approve branch and a reject branch, and a default timeout. Each decision can be used once. The wider gate system addresses a gate to a person, nudges them, escalates to a named fallback, and parks it. It never approves by itself.

  • Policy engine verdicts

    The policy engine returns allow, redact, ask or deny at control points such as a model call, a tool call, a workflow node and outbound traffic. A later guard can never soften an earlier verdict. Enforcement is live for runs that have a policy attached, and runs without one are not covered.

  • The run ledger

    Each run keeps an append-only ledger in which every event is linked to the one before it by hash. There is a call to read the events and a call to verify the chain. It is evidence that something happened and in what order. It does not decide anything.

How an approval works, step by step

The shape is the same across the built parts, even though the details differ.

  1. 01

    The agent proposes a call

    An agent decides it needs to run a tool, send a message or change a file. At that moment it has not done anything. The call is a proposal, with its arguments, and the system decides what happens to it next.

  2. 02

    The system holds it

    A check looks at the proposal. Low-risk reads pass. A risky or unknown call is held, and the agent waits for an answer. High-risk actions, such as send, pay, delete, push and shell, are held even when auto-approve is on, because those are the ones that are hard to undo.

  3. 03

    A person is asked

    The request goes to a named person or a card in a chat, with enough detail to decide: what, where, and with which arguments. The decision is bound to that exact call, so approving one action does not approve a different one.

  4. 04

    The decision is recorded

    The decision is stamped with who made it, taken from the signed-in identity rather than typed in, and written to an audit record. The first decision wins, so two people cannot disagree about the same call. If nobody decides before the time limit, the call is not approved.

  5. 05

    The run continues or stops

    On approval the call goes ahead once, and only that call. On refusal or expiry it does not run at all. Where a run ledger is kept, it shows what was proposed and what was decided, in order, so a reviewer can follow it later.

Workflow gates, nudging and escalation

Workflow gates matter most when the person who must decide is busy. A gate is addressed to an assignee, not to a room. If the assignee does not answer, the gate is nudged, then escalated to a named fallback, and if nobody answers it is parked. Parked still means waiting for a decision. The design principle is explicit: a gate never auto-approves, because silence is not consent.

The human input step in a workflow follows the same idea. It pauses the run, waits for the assignee and routes to an approve branch or a reject branch. The default timeout is 24 hours as built. You can design a workflow so that a timeout rejects, which is usually the right choice for money and access. We do not claim that Swfte routes its own approvals through these gates today.

Decisions Swfte reserves to a person

Two examples from our own practice are in use today. The first is a live payment test in our Cortex application. A real charge was made to check billing, and the gate on it required that it be refunded or explicitly marked as kept by the owner. The agents did not decide. The handover said not to infer the decision from a commit request, and the owner later chose to keep it.

The second is the key used to sign releases of the application. It is held by the founder, and the release runbook lists the steps that need the founder, so an agent cannot publish a signed release without that person. Another practice is a repository rule telling AI assistants to propose before executing. It is a rule, not a mode in the app, and many sessions have run autonomously when asked to. We give no names or figures here.

What is not built

Several things that sound like they exist do not yet. There is no single approval inbox: approvals exist in several parts of the platform, and a person who must handle them all uses several screens. The platform does not enforce that the approver differs from the requester, so the four-eyes rule is something a team applies by how it organises itself. Roles and delegation for approvers are listed as gaps.

The Trust Profile, a single record that names an AI system's owner, risk level and approval rule, is not in the product as one record. Its controls exist in separate pieces that are not joined. Autonomy levels from L1 to L5 are likewise not a setting: no agent carries one. Our platform pages describe both as the design. Treat them as the shape we are building towards, not as something you can switch on.

A worked example, labelled design intent

This is how we would handle customer refunds with an agent, as design intent. We have not run it. The agent reads the request, checks the order, and prepares a refund recommendation. Under the approval threshold it drafts the refund and waits. Above it, the draft is addressed to a named finance approver. Nothing is paid until a person decides.

The approver sees the order, the policy applied and the amount. If they approve, the payment step runs once and the decision is stamped with their identity. If they do not answer, the gate is nudged and escalated, then parked. The ledger records each step. The threshold is <approval threshold - set by the process owner>. If we have a real approval of our own to show, it will replace this one: <real example of an approval Swfte routed through Nexus - founder to fill>.

What stays with a person, and where to go next

A person decides anything that moves money, changes access, sends words in your name or deletes something that cannot be restored. A person sets the threshold and chooses the fallback approver. A person reads the ledger when something goes wrong. A person decides to trust an agent with more, one step at a time, and writes down why.

For the wider design of governed agents, with their limits, approvals and records, read the governed agents page. For how the same ideas apply to regulated processes with sign-off, read the compliance workflows page. Both describe how you can do it. They do not describe what Swfte has already done, which is what the evidence table below is for.

Approvals and governance: what is in use, built and designed

The first two rows are Swfte practices. The built rows describe the product. The last two rows are not built.

What is in use at Swfte, built in the product and designed for: Approvals and governance
PracticeStatusWhat we can point to
Decisions reserved to the owner: a live payment test kept by explicit owner decision, and a release signing key held by the founderIn use at SwfteRecorded in our handover and release documents. No names or figures are published.
A repository rule that AI assistants propose before executingIn use at SwfteA rule for assistants working in a repository, not a mode in the app. Many sessions have run autonomously on request.
In-app approvals bound to the exact call, single use, with a hash-chained audit logBuilt in the productIssued by the main process, not the interface layer. The audit log records metadata only.
Nexus approval cards with first decision wins and expiryBuilt in the productThe decider is taken from the signed-in person. An unanswered card expires into a refusal.
Workflow gates: human input step, assignee, nudge, escalation and parkingBuilt in the productA gate never approves by itself.
Policy engine verdicts: allow, redact, ask, denyBuilt in the productLive for runs that have a policy attached. We found no interface for writing policies.
Run ledger with a hash chain and a verify callBuilt in the productAppend-only events per run, readable and verifiable through the API.
A single approval inbox, approver separate from requester enforced by the platform, roles and delegationDesigned forNot built. Approvals live in several parts of the platform.
Trust Profile as one record and autonomy levels L1 to L5 as a settingDesigned forNot in the product as settings. Our platform pages describe the design.

How to read the status

  • In use at Swfte. We can point to it in our own repositories, pipelines or commit history.
  • Built in the product. The product can do this today. We make no claim that we run it on ourselves.
  • Designed for. How you can do it. Design intent, not a statement about what we have done.

Frequently asked questions

Does Swfte run this on its own company information?

In part. We keep some decisions with a person: a live payment test was kept by explicit owner decision, and the release signing key is held by the founder. We do not route our own approvals through Cortex or Nexus workflows as a company practice that we can evidence. The approval mechanisms on this page are built in the product.

Is there one place where I approve everything?

No. Approvals exist in several parts of the platform: in Cortex, in Nexus, in workflow gates and in the policy engine. They do not share one model or one inbox. A single approval inbox is design intent. If you plan a rollout, expect to handle approvals in more than one place.

Can the platform stop the same person requesting and approving?

Not as an enforced rule today. We found no check that the approver differs from the requester, so four-eyes review is something a team arranges by who it assigns. Enforced separation, with roles and delegation, is designed for and not built. Plan for it as process until it is.

What happens if nobody answers an approval?

It depends on the part. In Cortex an unanswered prompt is refused, and an unanswered Nexus card expires without approving the call. A workflow gate is nudged, escalated to a named fallback and parked, and it never approves by itself. A human input step has a default timeout, and you should design it to reject for sensitive actions.

Can an agent approve its own action?

The approvals described here are decided by a person, and the decider is taken from the signed-in identity. Policy verdicts let you deny or ask. But an enforced rule that the approver differs from the requester is not built, so do not rely on the platform alone to prevent self-approval.

Are the policy engine and run ledger live?

They are built. The policy engine enforces only for runs that have a policy attached, and we found no interface for writing policies. The run ledger links events by hash, with calls to read and verify them. The ledger is evidence. It records what happened and decides nothing.

Are Trust Profile and L1 to L5 settings in the product?

Not yet. The Trust Profile as one record and the autonomy levels L1 to L5 are the design described on our platform pages. The controls they name exist in separate pieces, and no agent carries a level as a setting. Use them as a planning model, not a feature to enable.

Take approvals and governance further with Swfte

Start with one entry point. Add intelligence, agents, workflows and infrastructure as you prove value.

Centralise your knowledge in Cortex

The desktop AI workspace: 20+ providers, local models, knowledge bases with RAG that cite their sources, MCP tools and agents, with sensitive work staying on the laptop by default.