Typical retry logicRISK
tool call→timeout→retry→duplicate?
The application collapses “I did not receive a response” into “the provider did not commit.” Those are different facts.
Effect integrity for autonomous software
Let agents act.
Keep the consequences under control.
AgentK sits between AI-agent intent and real-world tool actions. When the provider may have committed but the response disappears, AgentK preserves the uncertainty, blocks unsafe retry, and reconciles with evidence instead of guessing.
THE FAILURE MOST SYSTEMS MISREAD
01Agent“Issue refund”
02AgentKClaim + contract
03ProviderRefund committed
AgentK state
AMBIGUOUS
ordinary retry blocked
Reconcile against provider evidenceOutcome becomes known without a duplicate action.
COMMITTED · 1×
The problem
A timeout tells you the response failed.
It does not tell you the action failed.
If an agent charges a card, sends a customer message, changes a CRM record, or issues a refund and the network dies at the wrong moment, your application may not know whether the effect happened. Retrying can duplicate the consequence. Not retrying can strand the work.
AgentKHONEST
tool call→unknown→block→reconcile
Uncertainty becomes durable state. The action keeps its identity, ordinary retry stays blocked, and provider evidence settles reality.
Where AgentK fits
Not another agent framework.
The layer between intent and consequence.
Reasoning + orchestrationYour agent frameworkDecides what it wants to do
↓ proposed tool action
Effect integrityAgentKIdentity · claim · policy · approval · ambiguity · reconciliation · evidence
↓ bounded execution
Consequential systemsPayments · Messaging · CRM · Infrastructure · APIsWhere real-world state changes
How it works
Seven boring steps.
That is the point.
AgentK keeps the final commit path deterministic. Models may help configure or explain; they do not decide whether an uncertain write is safe to repeat.
- 01
Describe
Declare the effect, retry semantics, visibility, approval mode, and recovery shape in an Effect Contract.
- 02
Identify
Give the proposed action a stable identity so the same consequence can be recognized across retries and restarts.
- 03
Claim
Acquire execution authority atomically so two workers cannot both believe they are allowed to perform the same action.
- 04
Decide
Apply deterministic policy and approval rules bound to the exact action snapshot.
- 05
Execute
Record known success—or preserve sticky ambiguity when the external result is genuinely uncertain.
- 06
Reconcile
Use provider evidence to settle uncertain outcomes instead of blind retry.
- 07
Prove
Retain durable, tamper-evident operational evidence for what was proposed, permitted, observed, and resolved.
Proof over promises
Designed around the failures that only appear after production.
AgentK’s core invariants are intentionally narrow: observation is passive, claims are atomic, ambiguity is sticky, evidence does not redefine provider reality, and recovery never pretends compensation is rollback.
✓
Durable action stateMemory for development; SQLite and Postgres for durable execution.
✓
Operational ambiguity inboxOperator API and UI for uncertain work, approvals, chronology, and evidence.
✓
Signed policy deliveryContent-addressed bundles, trust roots, staged activation, durable delivery evidence.
✓
Explicit recovery semanticsReversible, compensable, and irreversible effects remain meaningfully distinct.
flagship-demo
$ npm run demo
effect payments.refund
identity refund:order-42
provider committed
response lost
→ outcome ambiguous
→ retry #1 blocked
→ process restarted
→ retry #2 blocked
→ evidence provider record found
→ reconciled committed
provider refunds: 1Start small
Protect one consequential tool call.
Use observe mode to map effects without changing application behavior, then move selected actions into enforcement when the contracts and recovery paths are ready.
Install
npm install @agentkagent/sdkNode 22.13+TypeScript / ESMNo database required for first run
Minimal shapeTypeScript
const runtime = new AgentKRuntime({
mode: "enforce",
store: new MemoryActionStore(),
});
const protectedTool = runtime.protect({
contract,
idempotencyKey,
execute,
});
const result = await protectedTool(args);Access model
Open core. Paid operational confidence.
The SDK is Apache-2.0. The commercial wedge begins where teams need production rollout, provider proof, shared operations, and eventually a managed control plane.
CommunityAvailable now
$0 open source
Build and self-host the effect-integrity layer yourself.
- Core SDK + Effect Contracts
- SQLite + Postgres durability
- Operator API + UI
- Policy + audit primitives
- Self-hosted deployment paths
FOUNDING ACCESS
ProductionOpening next
Paid founding tier
For teams moving consequential agent actions into real production.
- Production rollout guidance
- Release assurance + upgrade path
- Provider capability expansion
- Priority incident support
- Future managed-control-plane credit
ManagedPlanned
Custom control plane
Shared policy, approvals, evidence retention, and ambiguity operations without running every control-plane component yourself.
- Hosted operational control plane
- Team identity + approvals
- Central policy distribution
- Evidence retention + alerting
- Enterprise support
Why no checkout button yet?AgentK already has its own Stripe billing path in test mode, but live-mode billing is intentionally refused until it is proven. Production access should not depend on a payment path that the product itself would not yet trust.
Founding-team intake can be connected to the live access workflow when deployment is wired.
No magic claims
AgentK says less on purpose.
Not exactly-once.
Arbitrary external systems are not transactional just because an agent called them through a library.
Not universal rollback.
Compensation is a later effect. It does not erase the original committed consequence.
Not a policy-only gateway.
Authorization can permit a write. It cannot determine whether a timed-out provider already committed it.
Not an agent framework.
Keep the planner and orchestration stack you like. AgentK owns the effect boundary beneath it.
The principle
Unknown is a real state.
Once autonomous software can change the world, “probably failed” is no longer an acceptable recovery strategy.