/projects/agentops
AgentOPS
A TypeScript operations architecture for agent scheduling, runtime execution, policy enforcement, verification, context management, and observability across long-running autonomous workflows.
AgentOPS
Deterministic operations stack for scheduled and governed agents
07
Project context05
Problem
Autonomous agents that run on schedules or events need operations discipline: queues, policies, approvals, scoped context, verification, observability, and receipts.
Solution
AgentOPS models a deterministic operations stack where schedules and events feed run queues, policy gates bound tool use, context capsules keep runs focused, verifiers prove outcomes, and traces make long-running work inspectable.
Challenges
The hard part is avoiding both extremes: agents cannot be unbounded cron jobs, but they also cannot require a human to manually coordinate every routine workflow.
Innovation
The architecture treats autonomous agents as operations infrastructure. Schedules, context, policy, verification, and traces become first-class runtime planes.
Domain expertise
This highlights Stefan's operating-system view of agent products: scheduling, queues, capability policy, scoped memory, postcondition checks, and observability for durable automation.
Case study evidence11
Outcomes
- Defines a control-plane pattern for scheduled and event-driven agent work.
- Keeps autonomous execution policy-bound and auditable.
- Shows how agent operations can be measured and improved instead of treated as opaque background work.
Architecture decisions
- Scheduler and queue control dispatch and concurrency.
- Policy and approval gates sit before tool execution.
- Verification checks and receipts prove whether the run succeeded.
Domain expertise signals
Agent operationsSchedulingPolicy gatesContext capsulesObservability
Technical deep dive09
AgentOPS frames autonomous agents as operations infrastructure. Its value is in making scheduled work, event-triggered runs, policy gates, context capsules, verification, traces, and receipts explicit.
Dispatch model
Scheduled and event-driven agents need a queue and concurrency model. Without that, recurring automation can race itself, duplicate work, or run without a clear owner.
Policy before tools
The architecture puts capability policy and approvals before tool execution. This turns autonomy into a governed runtime instead of a cron job with model text in the middle.
Context economics
Context capsules make each run smaller and safer. They avoid giving every scheduled agent all memory, all history, and all secrets when the task only needs a narrow brief.
Operational proof
Postcondition checks, receipts, traces, and metrics give operators evidence that the run actually completed. The agent's output is not enough; the runtime needs proof artifacts.
What this proves
- Scheduling and queue layers are separate from model execution
- Policy and approval gates precede actions
- Context capsules scope each run
- Verification and receipt bundles define completion
4control planes
2dispatch modes
1policy engine
Nrun receipts
Ncontext capsules
100%verified runs
Technology stack06
TypeScript
Operational agent state benefits from typed schedules, policies, receipts, and events.
Node.js
Fits queue workers, HTTP APIs, and TypeScript service orchestration.
Redis
Useful for queues, concurrency control, and short-lived run state.
PostgreSQL
Stores run history, context, policies, and receipts with audit-friendly durability.
OpenAI
Model provider for planning and synthesis inside the operations runtime.
AI SDK
Keeps agent streaming and tool abstractions consistent with the TypeScript stack.
Tools implemented08
Scheduler
Starts agent runs from time-based and event-based triggers.
Run queue
Controls concurrency and prevents overlapping automation from racing.
Policy engine
Applies capability limits before tools execute.
Approval gate
Routes risky actions to a human checkpoint.
Context capsule
Keeps each run scoped instead of flooding the model with all memory.
Verifier
Checks postconditions before marking work complete.
Receipt bundle
Captures the proof needed to audit the run later.
Trace stream
Makes long-running agents observable while they operate.