How the Agent Tick Works

Every autonomous system has a core loop. For a game engine, it’s the render cycle. For a control system, it’s the feedback loop. For a corporate agent, it’s the tick.

The tick is the atomic unit of agent behavior in TheCorporation. One tick, one cycle of observation, evaluation, and action. Understanding the tick is understanding how an agentic corporation actually works — not as a metaphor, but as a mechanism.

Observe

The tick begins with observation. The agent reads the current state of the corporate entity: formation documents, cap table, compliance obligations, treasury balances, pending deadlines, governance resolutions. This state lives in the entity’s git repository, which means the agent is reading committed, versioned, cryptographically-linked data — not a mutable database that might have changed since the last read.

The observation phase produces a structured snapshot. Not the raw files — the parsed, validated, typed representation of the entity’s current state. If the bylaws specify a four-person board, the agent knows there’s a four-person board. If the cap table shows 10,000,000 authorized shares with 2,500,000 issued, the agent knows exactly what’s available. If a franchise tax is due in 72 hours, the agent knows the deadline, the amount, and the filing requirements.

This snapshot is the agent’s entire world. It cannot see anything outside the repository. It cannot access data it hasn’t been scoped to read. The observation is complete within its scope and empty outside it.

Evaluate

With the snapshot in hand, the agent evaluates what needs to happen. This is where the LLM does its work — reasoning about the current state against the entity’s rules, obligations, and pending requests.

The evaluation produces candidate intents. An intent is a structured description of a proposed action: file a document, issue shares, update a record, send a notification. Each intent has a type, a payload, and an idempotency key.

The idempotency key is critical. It ensures that the same observation, evaluated multiple times, produces the same intent — and that the intent executes at most once. If the agent ticks twice before the first tick’s results are committed, the duplicate intent is deduplicated by its key. The system is convergent, not additive.

Intents are proposals, not actions. The agent has identified what it believes should happen. It hasn’t done anything yet.

Gate

Before any intent executes, it passes through the policy gate. The gate is the governance layer — the programmatic expression of the entity’s rules about who can do what, when, and under what conditions.

The gate checks three categories of constraint:

Authority. Does this agent have the scopes required to perform this action? An agent with compliance_write scope can file compliance documents. It cannot issue equity. The scope check is binary — the agent either has the scope or it doesn’t. There’s no escalation, no override, no “just this once.”

Governance. Does this action require approval that hasn’t been granted? A routine compliance filing might be pre-approved by standing resolution. An equity issuance might require board consent. A bylaw amendment might require shareholder vote. The gate checks the governance requirements and either passes the intent through or routes it to the appropriate approval workflow.

Consistency. Does this action conflict with the current state? You can’t issue more shares than are authorized. You can’t file a tax return for a period that hasn’t ended. You can’t approve a resolution without quorum. The gate enforces invariants that the agent’s LLM might not catch.

An intent that passes all three checks proceeds to execution. An intent that fails authority or consistency is rejected outright. An intent that requires governance approval enters a pending state, waiting for the appropriate human action.

Execute

Approved intents execute as side effects, each producing one or more mutations to the entity’s state. A document filing creates a new file in the repository. An equity issuance updates the cap table. A compliance action updates the obligation tracker.

Every mutation is a git operation. New files are added. Existing files are modified. The changes are staged, committed, and — critically — signed. The commit message records what happened, the commit metadata records who authorized it, and the commit signature provides cryptographic proof of authenticity.

The idempotency key is written into the commit. If the same intent somehow reaches execution twice, the second attempt detects the existing key and no-ops. The system’s at-most-once guarantee is enforced at the storage layer, not at the application layer.

The commit

The tick ends with a commit. The commit is the tick’s output — a single, atomic, auditable record of everything the agent did in this cycle. The commit message summarizes the actions taken. The diff shows exactly what changed. The signature proves who authorized it. The parent hash links it to the complete history of the entity.

This commit is the corporate record. Not a log entry about the corporate record, not a database row that represents the corporate record — the commit is the record. The action and its documentation are the same artifact.

Why ticks matter

The tick model gives you three properties that matter for corporate governance:

Atomicity. Each tick either completes fully or not at all. There’s no state where half of a compliance filing was processed. The commit either includes all the changes or none of them.

Auditability. Every tick produces a commit. Every commit has a diff, a message, a timestamp, and a signature. The complete history of every agent action is the git log.

Convergence. Idempotent intents mean the system converges to the correct state regardless of how many times the tick runs. If an agent crashes mid-tick and restarts, it observes the same state, generates the same intents, and — finding that they’ve already been executed — does nothing. The system is self-healing by construction.

The tick is simple. Observe, evaluate, gate, execute, commit. Five steps, one cycle, one commit. Everything the agentic corporation does is this loop, running on a schedule, producing an immutable record.

That’s the whole machine.