Implementation comparison

Compare agent projects. Inspect the evidence.

Compare model support, tools, collaboration, durable execution, and operational guarantees across agent projects.

Explore the capabilities Read the SIGKILL test

Source audit updated October 7, 2026. Public Python releases checked on this date.

01 · Capabilities and comparison

Compare the capabilities. Expand the details.

This source audit describes the public releases and optional components linked below. “Not found” means the inspected implementation did not establish the capability. Partial cells name narrower implementations; closed components and external engines are identified explicitly.

140 capabilities25 audited comparisons

Each row compares one named capability across projects. Open a group heading for all Cayu sub-points and their public sources.

Yes
Implemented in inspected code
Partial
Partial or different scope
External
External dependency
Not found
Not established in inspected code
Unverified
Not inspectable in this audit

On narrow screens, scroll the table sideways to compare all projects.

Expandable capability comparison across Cayu and Python agent projects
Production capability	Cayu	LangGraph	OpenAI Agents	PydanticAI	Claude Agent SDK	CrewAI

Cayu details Choose providers, govern model calls, and validate outputs. Provider portability OpenAI, Anthropic, Google, Amazon Bedrock, and Vertex integrations. Compatible and local endpoints Use compatible model APIs, including Ollama and vLLM. OpenRouter and Cayu Gateway Explicit routing, preserved provider state, and reported-cost evidence. Durable model failover Explicit fallback targets retain budgets, deadlines, and selection authority. New-session model policies Opt in to governed model-policy adoption for new sessions. Structured output Native schemas, validation, and bounded output repair. Reasoning configuration Typed thinking settings with model and transport compatibility checks. Multimodal inputs Images, PDFs, and file attachments where the selected provider supports them. Streaming and non-streaming calls Provider events share runtime execution and accounting contracts. Prompt caching Cache configuration and provider-reported cache-usage accounting. Hosted web search Native search with retained source, citation, and usage evidence. Background-response recovery Reconnect to a recorded OpenAI background response after worker loss. Experimental provider paths Subscription authentication for local development/evaluation, and TypeSafe integration. Inference inside tools Managed auxiliary inference participates in runtime limits and accounting. Provider guide
Model providers	Implemented in inspected code: Multiple provider adapters	External dependency: LangChain model adapters	Implemented in inspected code: OpenAI + LiteLLM adapter	Implemented in inspected code: Multiple provider adapters	Partial or different scope: Claude model configuration	Implemented in inspected code: Native + LiteLLM providers
Structured output	Implemented in inspected code: Schema validation + retries	Partial or different scope: LangChain model-backed schemas	Implemented in inspected code: Typed JSON output	Implemented in inspected code: Schemas + output validators	Partial or different scope: JSON schema passed to CLI	Implemented in inspected code: Task Pydantic / JSON output
Governed model failover	Implemented in inspected code: Retained selection + budget authority	Partial or different scope: Dynamic models; app failover	Partial or different scope: Model adapters; app failover	Partial or different scope: FallbackModel; caller recovery	Not inspectable in this audit: Fallback option; closed CLI	Partial or different scope: Provider adapters; app failover

Cayu details Continue from retained evidence after interruption or worker loss. Checkpointed sessions Persistent transcripts, checkpoints, and supported resume boundaries. Execution ownership Leases and fencing prevent stale workers from retaining execution authority. Execution-profile compatibility Immutable profiles detect changed tools, policies, and dependencies before continuation. Partial tool-round recovery Retain settled sibling results while reconciling unfinished calls. Ambiguous-effect reconciliation Inspect uncertain effects and reconcile authoritative downstream receipts. Lost-acknowledgement settlement Durable operation receipts preserve exact replay and settlement identity. Application shutdown Bounded draining, per-step cleanup outcomes, and retryable incomplete cleanup. Session closure Explicit closure retains descendant and cleanup evidence. Protected session steering Conditional message delivery, inspection, withdrawal, and quarantine. External-event waits Early delivery, duplicate handling, timeout election, and restartable continuation. Unknown effects stay fenced until authoritative evidence resolves them. Recovery depends on the configured stores, adapters, and execution profile. Runtime contracts External-event waits
Crash resume	Implemented in inspected code: Built in	Implemented in inspected code: With checkpointer	Partial or different scope: Caller-persisted RunState	Partial or different scope: Snapshots / external engine	Partial or different scope: Transcript resume	Partial or different scope: Runtime + Flow checkpoints
Ambiguous-effect recovery	Implemented in inspected code: Fence + reconcile	Not established in inspected code: Unsettled tasks rerun	Not established in inspected code: No pre-effect ledger	Partial or different scope: Effect ledger; caller reconciles	Not inspectable in this audit: Closed CLI	Not established in inspected code: No durable start barrier

Cayu details Expose useful tools under explicit runtime policy. Native Python tools Validate declared JSON schemas before policy, approval, and execution. Parallel tool execution Tools declare whether they can execute safely alongside siblings. Parameter-level policy Allow/deny decisions and constraints on the actual requested arguments. Large-catalogue discovery Discover tools without exposing the entire catalogue in every model request. Targeted tool grants Scoped grants and the portable call_tool gateway preserve runtime authority. MCP integration Stdio/HTTP transports, manifest checks, refresh, and tool-list subscriptions. Process-isolated host tools Hard Linux process deadlines for non-cooperative trusted dependencies; this is not a sandbox. Origin-based taint policy Track untrusted tool content and inherit its policy labels across forks. Private argument continuity Preserve authorized private arguments across recovery and safe transcript projections. Tool contracts Process-isolated tools MCP coverage
Runtime tool authority	Implemented in inspected code: Built in	Partial or different scope: Application tool wrappers	Partial or different scope: Approvals + guardrails	Partial or different scope: Approval toolsets + hooks	Partial or different scope: Callbacks; CLI enforcement	Partial or different scope: Application hooks

Cayu details Pause for decisions without losing the execution boundary. Restart-safe tool approvals Retain pending decisions and bind resolution to the exact tool occurrence. Business approvals Tiered routing and attributable application-owned decisions. Durable human input Retained questions, typed answers, and checkpointed continuation. Human-attention notifications Durable delivery, deduplication, and authoritative pending-action repair. Policy-controlled review Disclose only the pending question or approval content an operator may inspect. Tool-backed completion Require a final tool or successful application-tool result before stopping. Human attention Human review
Restart-safe approvals	Implemented in inspected code: Built in	Partial or different scope: Durable interrupt only	Partial or different scope: Caller persists state	External dependency: Deferred / external	Not inspectable in this audit: Closed CLI	Partial or different scope: Checkpointed HITL

Cayu details Bound execution and retain the evidence behind cost estimates. Execution limits Bound model steps, tool calls, tokens, and elapsed execution time. Dollar reservations Reserve priced estimated spend before dispatch and settle retained usage. Durable budget ledgers Application, agent, session, and causal scopes with explicit time windows. Common-root reservations Share root and ancestor budget authority across collaborating work. Model catalogues and price books Versioned capabilities, matching rules, and provenance-bearing prices. Usage and cost attribution Inspect per-call, session, and causal token/cache usage; separate charges from estimates. Cost-and-quality comparisons Paired evidence supports measured optimization claims. Runtime estimates, reservations, and reported provider charges are distinct. Guarantees require applicable pricing and configured reservation bounds. Cost governance Common-root budgets
Dollar budget enforcement	Implemented in inspected code: Reserve + settle	Not established in inspected code	Not established in inspected code	Partial or different scope: Cost + spend limits	Not inspectable in this audit: CLI budget option	Not established in inspected code

Cayu details Fit the next request while preserving useful retained state. Request-footprint estimates Count context against the complete provider request shape. Context-selection policies Message windows, recent-turn selection, and attachment trimming. Compaction strategies Summarization, checkpoint-delta compaction, and cache-aware compaction. Context-overflow recovery Classified overflow and bounded compaction/retry behavior. Scoped transcript search Retrieve permitted historical conversation text under explicit bounds. Large-result externalization Store oversized tool results as artifacts and expose bounded model projections. Context contracts
Context recovery	Implemented in inspected code: Built in	Partial or different scope: Application history hooks	Partial or different scope: OpenAI Responses compaction	Implemented in inspected code: Harness compaction	Not inspectable in this audit: Closed CLI	Partial or different scope: Summarization

Cayu details Own allocation, execution admission, and resource recovery. Composable execution contracts Separate environment, runner, workspace, and factory responsibilities. Replaceable execution adapters Local, Docker, Lambda MicroVM, E2B, and Microsandbox integrations. Capability-based admission Check workload, tool, and isolation requirements before provider or tool execution. Recoverable allocation Exact-resource creation/reconnect and owner-fenced lifecycle operations. Checkpointed replacement Restore supported workspace files into an explicitly admitted replacement allocation. Deferred runner allocation Materialize a runner only when a session first needs it. Docker warm spares Bounded spare pools participate in allocation ownership and shutdown. Workspace bindings Native, synchronized, Git, and cloud-filesystem binding compositions. Docker and Lambda MicroVM are the maintained execution paths. Docker does not qualify as hostile-code isolation; other adapters have their own capability boundaries. Execution capabilities Environment factories
Isolated workspaces	Implemented in inspected code: Built in	Not established in inspected code	Implemented in inspected code: Docker + remote sandboxes	Implemented in inspected code: Optional harness sandboxes	Not inspectable in this audit: CLI sandbox settings	Not established in inspected code
Environment + runner contracts	Implemented in inspected code: Built in	Not established in inspected code	Partial or different scope: Sandbox backends	Partial or different scope: Workspaces / external engine	Not established in inspected code: CLI transport only	Not established in inspected code

Cayu details Inspect, change, retain, and hand off concrete work. File and repository tools Read, write, edit, delete, list, patch, search text, and inspect Git changes. Bounded commands Command output, timeouts, and cancellation have explicit execution contracts. Checks and toolchains Named checks, structured commands, and admitted Docker coding toolchains. Revision-aware mutations Bind workspace changes and publication to observed revisions and conflict checks. Speculative workspace branches Isolate candidate changes, publish eligible work, and recover supported branches. Immutable input resources Exact input capture and shared read-only projections remain separate from mutable work. Durable artifact storage Local/S3 storage, digests, retention pins, attachments, and workspace transfer. Shared-artifact handoffs Retain lineage-scoped artifact references across sessions. Named checks Workspace contracts Immutable inputs
Durable artifacts	Implemented in inspected code: Built in	Not established in inspected code	Partial or different scope: Workspace snapshots + files	Implemented in inspected code: Harness media stores	Not inspectable in this audit: Closed CLI	Partial or different scope: Output files only

Cayu details Search and interact with the web under application-owned boundaries. Portable search and fetch Provider-neutral tools with Exa and Parallel adapters. Explicit web routing Execution profiles, classified access barriers, and application-controlled routing. Stateful browser sessions Sandboxed browser interaction with governed navigation and semantic references. Source-bound readback Revision-bound rendered text and source-bound image-region inspection. Visual browser controls Explicit screenshot publication and revision-bound visual actions. Authenticated browser profiles Application-owned encrypted profile state with explicit retention policy. Private login and MFA handoff Private viewing, exclusive operator takeover, sensitive input, and agent handback. Browser recording Explicitly authorized, bounded sampled video with retained coverage metadata. Visual publication, operator access, profile retention, and recording are separately authorized. Backend recovery does not imply preservation of live browser state. Web execution Browser sessions Browser recording
Web search + fetch	Implemented in inspected code: Search / fetch provider adapters	External dependency: Application-supplied web tools	Partial or different scope: Hosted search; caller fetch	Implemented in inspected code: Native / local web capabilities	Partial or different scope: CLI WebSearch / WebFetch options	Implemented in inspected code: Optional search + scraping tools
Browser execution	Implemented in inspected code: Admitted stateful browser	External dependency: Application-supplied browser tools	Partial or different scope: Computer tool; caller executor	Implemented in inspected code: Optional harness browser adapters	Not inspectable in this audit: CLI / external browser execution	Implemented in inspected code: Optional Bedrock browser toolkit

Cayu details Keep secrets outside agent execution and govern outbound access. Vault-backed secret references Replaceable secret stores resolve application-owned references. Virtual credentials Broker real credentials without giving them to the agent execution environment. Network restrictions Destination controls, deny-by-default egress, and metadata-network protection. Brokered authentication Explicit credential modes support governed CLI and API access. Session-bound egress authority Revalidation, revocation, lifecycle ownership, and audit evidence. Virtual egress
Virtual credentials + egress	Implemented in inspected code: Built in	Not established in inspected code	Partial or different scope: Vercel network policy	Partial or different scope: Harness network controls	Not inspectable in this audit: CLI sandbox settings	Not established in inspected code

Cayu details Compose independent work with durable readiness and completion policies. Tasks and workers Durable queues, dispatch, competing workers, and process scaling. One-shot scheduling Revisioned rescheduling, cancellation, expiry, and explicit misfire policy. Dependency graphs Durable readiness, joins, and transitive failure propagation. Task completion groups All-success, first-success, and quorum policies retain exact contributing members. Quiescence and finalizers Drain losing work and require settlement before releasing a gated finalizer. Authored workflows Durable step journals and bounded failure evidence support application orchestration. Independent session forks Dispatch children from retained checkpoints while the parent continues. Foreground/background subagents Retain child-session lineage and independent lifecycle context. Child completion and pending actions Discover settled children and inspect delegated approval/input pauses. Task scheduling Dependency graphs Task groups
Tasks + dispatch + workers	Implemented in inspected code: Built in	Partial or different scope: Graph task scheduling	Not established in inspected code	Partial or different scope: Harness tasks / external engine	Not inspectable in this audit: Closed CLI	Partial or different scope: Crews + Flows
Forks + subagent lineage	Implemented in inspected code: Built in	Partial or different scope: Graph forks + subgraphs	Partial or different scope: Handoffs + tool agents	Partial or different scope: Harness snapshots + child lineage	Partial or different scope: Session forks + transcripts	Partial or different scope: Checkpoint branches + crews

Cayu details Ask, clarify, and exchange retained results across authorized participants. Participant administration Durable identities, aliases, mandates, and lifecycle controls. Recipient-session creation Participant-owned creation and fences retain exact destination identity. Historical context views Retained context selection keeps exact source and authorization boundaries. Authenticated peer content Delivery and provider exposure remain separately authorized facts. Durable requests and answers Admission planning and retained producer output survive reconstruction. Clarification service Bounded questions, replies, and explicit temporary service turns. Result waits and continuation Durable collaboration waits retain restartable result-delivery responsibility. Participant identities Peer content Collaboration requests
Multi-agent coordination	Implemented in inspected code: Registered participants + sessions	Implemented in inspected code: Graph routing + subgraphs	Implemented in inspected code: Handoffs + agents as tools	Implemented in inspected code: Optional harness subagents	Partial or different scope: Subagent definitions; CLI execution	Implemented in inspected code: Coworker delegation + A2A
Durable peer requests	Implemented in inspected code: Authenticated request receipts	Partial or different scope: Checkpointed graph state	Partial or different scope: Caller-persisted RunState	Partial or different scope: Persisted child records	Not inspectable in this audit: Peer durability in closed CLI	Partial or different scope: A2A tasks + crew checkpoints

Cayu details Accept work through independent checks of durable evidence. Immutable work contracts Freeze criteria, constraints, verifier identity, and evidence requirements. Independent verification Deterministic decisions and digest-bound result reconstruction govern acceptance. Bounded repair attempts Durable rejection history, repeated-gap detection, and continuation ceilings. Maintained coding product Evidence and exact-revision checks gate patch_ready_for_delivery. Approved remote Git delivery Two-phase delivery retains approval identity and reconciliation evidence. GitHub delivery and feedback Create/update a bound PR and observe checks and review feedback separately. The coding product publishes patch readiness. Remote Git and GitHub delivery are separate approved layers; the connector never merges. Verified work Coding product Git delivery GitHub delivery
Acceptance checks + repair	Implemented in inspected code: Frozen contracts + verifier decisions	Partial or different scope: Application verification nodes	Partial or different scope: Output guardrails; app repair	Partial or different scope: Output validators + retries	Partial or different scope: Hook callbacks; CLI repair	Partial or different scope: Task guardrails + retries
Git / GitHub delivery	Implemented in inspected code: Approved Git + PR receipts	Not established in inspected code: No Git delivery owner in graph core	External dependency: Optional Codex adapter	Partial or different scope: GitHub MCP; app delivery gates	Not inspectable in this audit: Delivery runs in closed CLI	Not established in inspected code: No maintained Git delivery owner

Cayu details Retrieve useful material while retaining provenance, access, and exposure evidence. Durable knowledge Chunking, lexical/semantic retrieval, and explicitly scoped access. Revision-bound knowledge Immutable source evidence, supersession, derivation, and contradiction relations. Cross-source recall Weighted rank fusion combines bounded sources, including custom adapters. Governed automatic recall Relevance gates, bounded offers, and explicit search fallback. Agent work context Application-owned task context has immutable revisions and compare-and-swap updates. Delta recall and delivery Checkpoint-aware processing and atomic staged delivery retain exact frontiers. Idle recall subscriptions Bounded, scoped subscriptions allow explicit processing while a task is idle. Memory-exposure evidence Recall receipts and provider-exposure lifecycles support bounded attribution. Reviewed curation and enrichment Independent evaluation, activation policy, and durable enrichment queues. Knowledge maintenance Governed consolidation and semantic watches retain explicit lifecycle authority. Memory foundation
Knowledge + memory stores	Implemented in inspected code: Built in	Partial or different scope: Store + semantic search	Partial or different scope: Sessions + sandbox memory	Partial or different scope: Harness memory + provider retrieval	Partial or different scope: Transcript store; memory in CLI	Implemented in inspected code: Knowledge + unified memory

Cayu details Turn retained behavior into repeatable cases and reviewable comparisons. Runtime-native assertions Check output, tools, events, children, files, artifacts, and usage. Trajectory scoring and replay Score retained trajectories offline and inspect runtime-contract evidence. Portable corpora and suites Retain authored cases and portable execution material. Production-session evaluations Capture real sessions, evaluate them, and promote reconstructable runnable cases. Multi-stage scenarios Exercise follow-up input, approvals, and resume under fresh authority. AI judges and calibration Structured rubrics and evaluator-only references support calibrated judging. Repeated trials Explicit trial policy retains individual outcomes and evidence gaps. Approved baselines Immutable baseline revisions and compatibility checks govern result comparisons. Durable benchmark campaigns Explicit recovery and selective retry preserve completed trial evidence. Parallel evaluation Multi-process execution, shared capacity, admission pacing, and retained inspection. Memory intervention reports Paired campaigns can assess causal contribution under validated controls. External evaluation targets Supported process/container targets participate through explicit contracts. Incremental workflow evidence Bounded capture and saved-attempt recovery avoid an unbounded in-memory trajectory. Portable agent snapshots Bundles retain supported state, component identity, and evaluation lineage. Evals reference Benchmark campaigns Incremental evidence Agent bundles
Trajectory evals + replay	Implemented in inspected code: Built in	Partial or different scope: Checkpoint re-execution	Partial or different scope: Tracing	Partial or different scope: Harness live judge + evals	Not established in inspected code	Partial or different scope: Trace evals + task replay

Cayu details Inspect what ran, what remains pending, and why execution stopped. Durable event history Append-only events retain ordered execution identities. Tracing, logging, and hooks OpenTelemetry and structured event sinks expose runtime activity. Durable event watchers Delivery, dead letters, and persisted side-effect health support operation. Read-only inspection Session/task topology, pending actions, outcomes, and usage projections. Timing and request-cost diagnostics Inspect runtime phases and the cost of constructed requests. Diagnostic support bundles Bounded, redacted provider and stream-failure evidence. Session inspection Event-side-effect health Support bundles
Durable event history	Implemented in inspected code: Built in	Partial or different scope: Checkpoints + pending writes	Partial or different scope: Sessions + event sinks	Implemented in inspected code: Harness step stores	Partial or different scope: Transcript mirror	Partial or different scope: Checkpoints + event replay

Cayu details Build an editable application and run it on your chosen infrastructure. Generated applications Editable application composition with coding and service presets. Developer CLI Project checks, diagnostics, console, and installed offline guides. Self-hosted control plane HTTP/browser clients, SSE, long polling, and conditional read models. OIDC and resource authorization Bearer verification and application-defined resource access with revocation. Public-agent services Customer-facing operations retain durable identities and result receipts. Application storage SQLite/PostgreSQL stores, schema inspection, migrations, and backup receipts. Cloud deployment Initialization, environment management, pre-upload checks, and release promotion. Project server Resource authorization Cloud CLI
Self-hosted control plane	Implemented in inspected code: Built in	Not established in inspected code	Not established in inspected code	Not established in inspected code: Dev web UI	Not established in inspected code	Not established in inspected code: Flow visualization only

Source review by Codex. Capabilities require the relevant stores, policies and adapters to be configured. Linked tests are implementation evidence; this is not a comparative benchmark.

Cayu 0.9.1 8d9ac8b

Durability uses configured session, event and checkpoint stores. The process-kill test leaves an ordinary tool effect unknown, keeps the session interrupted and prevents redispatch. Approval policy, budget reservation/settlement, credential brokering and resource ownership are runtime components; their guarantees require the matching policies, durable stores, price book and adapters. Provider failover retains model selection and budget/deadline authority. Web tools and browsers require admitted adapters/environments. Collaboration stores authenticated request/answer receipts. Verified work freezes contracts and records independent verifier decisions; optional Git/GitHub connectors deliver approved changes with recovery receipts.

LangGraph 1.2.14; checkpoint 4.2.0 in this source snapshot 70dd640

A configured checkpointer persists graph progress, pending writes and interrupts. Interrupted nodes restart from their beginning. Stores support memory and semantic search; graph state can be forked and subgraphs persisted. The inspected graph/tool execution path does not establish a general tool-effect reconciliation ledger, dollar reservations, credential broker, workspace/artifact ownership or an operations control plane. Those broader services can be supplied separately. The prebuilt agent accepts LangChain model adapters, dynamic model selection and model-backed response schemas. Send/Command routing and subgraphs coordinate graph work. Web/browser implementations are application-supplied tools outside graph core. Verification nodes, failover policy and Git delivery remain application responsibilities in this snapshot.

OpenAI Agents 0.23.1 c4a1d04

RunState serializes interrupted runs and approvals; the application must persist it. Sessions store conversation history, and sandbox backends provide workspaces and snapshots. The Vercel adapter forwards network allow/deny rules and header transforms to its provider. This credits provider-specific egress configuration without establishing a runtime-wide virtual-credential broker. The inspected function-tool execution path does not persist a general pre-effect reconciliation ledger or reserve dollar spend. Model support includes the optional LiteLLM adapter; typed output schemas, handoffs, agents as tools and output guardrails are implemented. Hosted web search is provider-backed; computer execution requires a caller-supplied computer. The optional Codex tool delegates to an external coding engine and does not establish the SDK-owned approved Git delivery contract compared here.

PydanticAI 2.54.0 + optional harness 0.54.0 (alpha) 6695132

The separately installed harness provides StepPersistence with file/SQLite stores, an awaited tool-start record and recovery inspection. Callers still decide how to reconcile effects and continue snapshots; Temporal, DBOS and Prefect supply workflow durability. Harness components also provide isolated sandbox backends, content-addressed media stores, compaction, memory, persisted child records and a live trajectory judge. SpendLimits blocks subsequent requests after recorded spend reaches a limit; in-flight and concurrent requests can overshoot. LocalWorkspace alone provides no isolation. Provider adapters, output validators/retries and FallbackModel are implemented. Native/local web capabilities and optional Playwright/browser-use harness adapters cover research and browser execution. Harness subagents coordinate child runs; the optional GitHub capability connects to GitHub MCP, including write tools. Those integrations do not by themselves establish frozen work acceptance or approved Git delivery receipts.

Claude Agent SDK 0.2.164 2f38c69

The public Python SDK implements permission callbacks, transcript mirroring, session stores and session mutations. It forwards resume, budget and sandbox settings to the Claude Code CLI. The CLI execution engine is outside this source audit, so its effect recovery, approval durability, budget enforcement, isolation and egress guarantees remain unverified here. This status does not assert that the product lacks those features. Model/fallback options, JSON output schemas, subagent definitions and web-tool selection are exposed by the SDK. Hook callbacks are public code; execution of web/browser tools, fallback, repair and repository delivery occurs in the CLI or external components and is not inspectable in this audit.

CrewAI 1.15.24 d5efc45

Runtime and Flow checkpoints preserve entities, event records and human feedback; checkpoint branches and task replay are implemented. Tool-start events are recorded in runtime memory, while checkpoint handlers run in a thread pool and tool execution does not await their completion. This does not establish a durable pre-effect barrier. Knowledge sources, vector storage and unified memory are implemented alongside trace evaluation. Output files and application hooks cover narrower scopes than runtime artifact and authority contracts. Native/LiteLLM provider adapters, task JSON/Pydantic output, guardrails with retries, coworker delegation and A2A task messages are implemented. Optional crewai-tools packages include search/scraping and a Bedrock browser toolkit. A2A task correlation and crew checkpoints cover narrower boundaries than authenticated durable peer requests. The inspected packages do not establish an approved Git delivery owner.

Choose for the guarantees your workload needs.

Follow the code, configuration, and deployment boundary behind each claim.

02 · The failure boundary

Recovery at a difficult boundary.

The tool acted. The result never arrived. What happens next?

Tool starts
Action authorized.
World changes
External effect.
Worker dies
Result missing.
Cayu recovers
Fence unknown effects.

A checkpoint tells you where the program was.

Cayu records the evidence needed to recover.

Kill the worker.

No silent re-execution.No invented result.Deliberate recovery boundary.

Proven in a real process-kill test

03 · Choose for the work

Choose a foundation for your domain.

What to evaluate

Look beyond the first run.

Assess each framework’s defaults, extension points, and execution guarantees against the work your agent needs to do.

Building with Cayu

Shape your agent in Python.

Assemble your domain-specific harness using Cayu’s components and defaults, with durable execution integrated into the framework.

Open-source Python framework for domain-specific long-horizon agents

Build for the long run.

Own the loop. Continue from evidence. Explain every outcome.

Build with Cayu View on GitHub

Compared against executable public code and tests inspected October 7, 2026. No vendor marketing claims used.

Compare agent projects. Inspect the evidence.

Compare the capabilities. Expand the details.

Expandable capability comparison across Cayu and Python agent projects

Models and the agent loop14 Cayu sub-points

Durability and recovery10 Cayu sub-points

Tools and execution authority9 Cayu sub-points

Approvals and human participation6 Cayu sub-points

Budgets, cost, and limits7 Cayu sub-points

Context management6 Cayu sub-points

Environments and infrastructure8 Cayu sub-points

Workspaces and artifacts8 Cayu sub-points

Web research and browsers8 Cayu sub-points

Credentials and network governance5 Cayu sub-points

Tasks, workflows, and subagents9 Cayu sub-points

Durable collaboration7 Cayu sub-points

Verified completion and coding products6 Cayu sub-points

Knowledge and memory10 Cayu sub-points

Evaluations and portable agents14 Cayu sub-points

Observability and operations6 Cayu sub-points

Application development and deployment7 Cayu sub-points

Audit scope and method

Inspected releases and source evidence