TPipe is an Agent Operating Substrate — the foundational environment AI agents inhabit. Unlike frameworks (chains, graphs) that you call, TPipe provides managed infrastructure: Reasoning Pipes, persistent ContextBank memory, Pipeline orchestration, and strict resource governance. Agents are residents of TPipe, not just users of a library.

How does TPipe compare to LangChain and CrewAI?

TPipe provides persistent ContextBank memory, dedicated Reasoning Pipes with 75% token reduction, and built-in Token Governance. LangChain uses local variables and prompt engineering for reasoning; CrewAI uses role-based agents with limited memory. TPipe is headless-first, designed for production autonomous systems.

What are Reasoning Pipes and Chain-of-Draft?

Reasoning Pipes execute specialized chain-of-thought processing before the main pipe. Chain-of-Draft (CoD) achieves 75% token reduction vs standard Chain-of-Thought with 78% latency decrease while maintaining accuracy. Uses concise 5-word-or-less reasoning steps ideal for mathematical and cost-sensitive production tasks.

What is ContextBank memory?

ContextBank is a thread-safe global persistent memory layer. Unlike local variables that vanish, ContextBank persists across sessions and distributed systems. Share context across pipes, maintain state over 120+ turn conversations, and organize memory with named page keys.

Does TPipe support multi-agent orchestration?

Yes — three patterns: Manifold, Junction, and DistributionGrid. Manifold handles manager-worker hierarchy. Junction enables democratic voting and handoff. DistributionGrid routes across distributed nodes. Each handles different collaboration patterns from coordinated teams to peer-to-peer agent swarms.

How do I get started with TPipe?

Install TPipe via Gradle dependency, then configure your first Pipe with Reasoning Pipes and ContextBank. Set up AWS credentials via environment variables. TPipe runs headless — no UI required. Start with a single pipe and compose into pipelines as needed.

How does Pipeline orchestration work?

Pipes chain sequentially — output of one becomes input of the next. TPipe supports pause/resume/jump flow control: repeat the current pipe, skip to a specific pipe by name, or terminate early. Declarative pause points enable human validation mid-execution.

What are DITL hooks and why use them?

Developer-in-the-Loop (DITL) functions are native code entry points — not bash hooks. Each of the 7 intervention points (Pre-Init, Pre-Validation, Pre-Invoke, Post-Generate, Validator, Transformation, On-Failure) gives you direct access to the content object and TPipe substrate. Inspect, modify, or enrich the execution context in real time — inject logic, validate outputs, or reshape the running program without touching the core pipe.

How does KillSwitch safety work?

KillSwitch is an emergency termination that bypasses all retry policies. When token limits are exceeded, KillSwitch propagates as an uncaught exception — no way to accidentally catch and ignore it. Loop Limit safety halts after configured iterations (default: 100).

Can I pause and resume agent execution?

Yes. TPipe supports pause/resume/jump at declaration points. Pause inserts a blocking state; resume continues with updated context. Jump can skip forward or backward to specific pipes. Essential for human-in-the-loop validation and long-running autonomous tasks.

What LLMs does TPipe support?

TPipe supports AWS Bedrock, Ollama, and OpenRouter. AWS Bedrock (Claude 3, GPT-OSS) is the primary tested integration. Ollama runs local models. Any LLM accessible via standard transport executors (Stdio, HTTP, Python, Kotlin, JavaScript) is supported. Configure credentials via environment variables or IAM roles.

How do I debug agent execution with TraceServer?

TraceServer provides real-time WebSocket streaming to a web dashboard. Configure detail levels (Minimal to Debug), output formats (JSON, HTML, Markdown), and automatic cycle detection for nested pipes. Enable with setTraceConfig() and connect browsers to the TraceServer endpoint.

How does TPipe handle token governance?

TokenBudgetSettings enforce strict resource accounting. Configure max tokens, context window size, and automatic truncation strategies (Top, Bottom, Middle). Token budgeting can subtract from input rather than output. Automatic KillSwitch termination prevents runaway costs.

What deployment options does TPipe support?

TPipe is headless-first — runs as a cluster of headless processes. P2P Registry enables agent discovery across nodes. MemoryServer provides centralized state. Designed for autonomous systems: 25 rounds, 120+ turns without degradation. Docker and Kubernetes compatible.

How does TPipe ensure production reliability?

Three layers: Safety (KillSwitch + Loop Limits), Governance (Token Budgeting + TraceServer audit trails), and Reliability (configurable Timeout/Retry with Fail/Retry/CustomLogic strategies). Snapshot-based state restoration for retry with recursive propagation to child pipes.

Does TPipe support SSO/SAML authentication?

SSO/SAML authentication is planned for enterprise deployments. TPipe currently supports token-based authentication. Enterprise SSO/SAML integration is on the roadmap with priority given to production deployment requirements. Contact us to discuss your authentication needs and timeline.

Head-to-Head

TPipe vs CrewAI

Role-based crew orchestration vs infrastructure-first agent substrate. Different mental models for building multi-agent systems.

Category Agent Operating Substrate vs Role-Based Crew Orchestration

Memory Persistent across distributed runs vs Scoped to crew execution

Coordination P2P registry — no dispatcher bottleneck vs Manager inherit pattern

Long-Horizon Hundreds of millions of tokens — proven vs Context degrades past 30–50 turns

What CrewAI Actually Is

CrewAI is a Python framework for orchestrating role-based agents. You define Agents with specific roles (researcher, writer, analyst), assign them tasks, and the crew executes those tasks in sequence or hierarchically. The manager pattern is central — a manager agent coordinates subordinate agents, delegates tasks, and synthesizes results.

This is genuinely useful for workflows where tasks map cleanly to roles and the process is predictable: research pipelines, content generation chains, multi-step analysis tasks. If you need five agents with distinct responsibilities and a defined handoff order, CrewAI's model is natural and readable.

TPipe is an agent operating substrate — not a framework you call, but infrastructure your agents inhabit. It doesn't have roles or crews. It has Pipelines, Containers, ContextBank, and three coordination patterns (Manifold, Junction, DistributionGrid). The mental model is different: you're describing a persistent environment with enforcement boundaries, not a workflow with role assignments.

The comparison matters because CrewAI is frequently cited as the "easy" multi-agent framework — if you're evaluating it for production agent infrastructure, you should understand what you're choosing between.

Architecture Comparison

Category

What it actually is

Agent Operating Substrate

Infrastructure your agents inhabit

Role-Based Orchestration

Python framework for crew workflows

Agent Model

How agents are defined and structured

Containers with P2PInterface — every agent implements P2PInterface with registry-based discovery. No role assignments — agents are capabilities registered in the P2PDescriptor. Agents communicate peer-to-peer, not through a dispatcher.

Agents with roles — each Agent has a role (researcher, writer, etc.), goal, and backstory. The role defines the agent's behavior. Crews compose multiple agents with process flows (Sequential, Hierarchical).

Memory Model

How state persists

ContextBank — persistent, global, thread-safe across distributed systems. Weighted lorebook injection with substring-triggered activation. Token-budget-aware retrieval. Survives restarts, spans sessions, coordinates across nodes without manual state management.

Crew-level memory — memory is scoped to a crew execution. Agents within a crew share context during execution. No persistent memory across runs without custom implementation. Truncation at the conversation level.

Coordination Pattern

How agents work together

Three distinct patterns: Manifold (state-machine manager-worker), Junction (voting/handoff between pipelines), DistributionGrid (cluster-wide P2P). P2P registry-based discovery — agents find each other by capability. No dispatcher bottleneck.

Manager inherit pattern — hierarchical process with a manager agent delegating to subordinate agents. Sequential process for ordered task execution. Crews define the handoff structure upfront.

Agent-to-Agent Communication

How agents discover and call each other

P2P (Pipe-to-Pipe) — registry-based discovery via P2PDescriptor. Every container implements P2PInterface. Capability registration. Transports: TPipe, HTTP, Stdio. Per-agent security boundary. Agents discover each other dynamically by capability, not by pre-defined crew structure.

Manager delegation. Agents communicate through the manager — subordinate agents report to the manager, which delegates back. No direct agent-to-agent communication without manager involvement. Sequential processes pass output to the next agent in the chain.

Token Governance

Cost control and enforcement

Token counting + truncation across ContextWindow, LoreBook, MiniBank, and Dictionary enforces memory budgets at the resource level. Tunable per-model tokenizer with TPipe-Tuner. This is memory resource management, not termination. KillSwitch is a separate system: it fires as an uncaught exception when accumulated tokens exceed a configured cap.

Crew-level limits. Token limits can be set at the agent or crew level. CrewAI's process handles context window management — but context degrades past 30–50 turns without manual truncation. No forced termination mechanism equivalent to KillSwitch.

Deployment Model

How it ships and runs

GraalVM Native Image — 50MB binary, no JVM at runtime, sub-128MB memory footprint, millisecond startup. Linux, macOS, Windows, ARM, Android (.so), iOS (.dylib). Headless-first.

Python runtime required. CrewAI is a Python framework — requires Python interpreter. Typically runs as a Python service or containerized with Python inside. Not headless-native — designed for workflow automation with task delegation.

ContextWindow Management

How context scales

ContextWindow with explicit truncation strategies (Top, Bottom, Middle). Token budgets can subtract from input — carve space for lorebook before main prompt. ContextBank persists across windows automatically. Autogenesis runs continuously, processing hundreds of millions of tokens with zero drift failures. 120+ turn tasks validated in production.

Conversation truncation. CrewAI handles context through the underlying LLM's context window. Long tasks require manual management of context. No automatic lorebook injection or persistent memory across runs.

Reasoning Control

How you influence LLM thought

8 reasoning methods: Structured CoT, Explicit CoT, Process-Focused CoT, Best Idea, Comprehensive Plan, Role Play, Chain of Draft, Semantic Decompression. 5 injectors: system prompt, before user prompt, after user prompt, converse history, context. Multi-round Focus Points. Structured JSON control over left-to-right token prediction — forces any LLM to reason through JSON schema, regardless of native capability. Bypasses model internal weights.

Role and backstory engineering. Agents are prompted with role, goal, and backstory. The manager coordinates based on crew process. No structured reasoning enforcement — the LLM thinks within the role constraints provided.

Fault Tolerance

What happens when something fails

KillSwitch — uncaught exception, propagates through the entire pipeline stack, cannot be absorbed. Works on Pipeline, Connector, MultiConnector, Splitter, Manifold, Junction, and DistributionGrid. Manifold Loop Limit — halts after configured iterations (default 100), throws ManifoldLoopLimitExceededException. TraceServer provides full execution record with token accounting.

Task-level retry. CrewAI supports retry configurations at the task and agent level. Errors propagate through the crew hierarchy. No forced termination equivalent to KillSwitch — retry handlers can absorb failures and continue.

Observability

How you see what's happening

TraceServer — WebSocket streaming to browser dashboard. Every decision captured, indexed, replayable. Detail levels Minimal to Debug. Automatic cycle detection. Full execution record with token accounting.

CrewAI Studio (cloud platform) or custom observability via callbacks and logging. No native self-hosted observability equivalent to TraceServer. Debugging via crew execution logs and task outputs.

Tool Integration

How tools are used

PCP (Pipe Context Protocol) — structured security managers with output validation before next pipe runs. Stdio, HTTP, Python, Kotlin, JavaScript transports. JSON schema enforcement at every boundary. Tools are PCP endpoints.

Built-in tool integration. Agents have access to tools via the `@agent` decorator. Tools are Python functions decorated with `@tool`. Output passes to next step — no structured validation gate between tool calls.

When to Choose TPipe

TPipe is the right choice when:

Headless operation matters. Agents that run around the clock, without human input at runtime, on server infrastructure. CrewAI is designed for task-oriented workflows with human oversight. TPipe is designed for continuous background processes.
Long-horizon tasks are non-negotiable. Context degradation past 30–50 turns is the failure mode. Autogenesis runs continuously, processing hundreds of millions of tokens with zero drift failures. CrewAI's crew-level memory doesn't persist across independent runs.
P2P coordination without dispatcher bottlenecks. If you need agents that discover each other dynamically by capability, not through a pre-defined manager, P2P is the model. CrewAI's manager inherit pattern requires all communication to flow through the manager.
Cost governance is a hard requirement. Memory budgets enforced at the ContextWindow / LoreBook / MiniBank layer with TPipe-Tuner calibration, plus KillSwitch as a separate safety net for token cap overruns. CrewAI's token management is advisory at the crew level.
You're deploying to non-x86 infrastructure. GraalVM Native Image runs on ARM, Android, iOS, embedded targets. Python frameworks like CrewAI don't ship as native binaries.

When to Choose CrewAI

CrewAI is the right choice when:

Role-based workflows fit your use case. If you have distinct roles (researcher, writer, editor) with clear task assignments and a defined process flow, CrewAI's role model is natural and readable.
Rapid prototyping with clear handoffs. Getting a multi-agent workflow working quickly matters more than production-ready infrastructure. CrewAI's crew structure is easy to understand and modify.
Python ecosystem integration is critical. If your team lives in Python and you're building workflows that fit the crew model, CrewAI reduces friction. The tool ecosystem integrates cleanly with Python packages.
Hierarchical delegation matches your problem. If your use case naturally has a manager coordinating subordinates, CrewAI's hierarchical process is a direct mapping. Sequential processes for ordered handoffs also fit cleanly.

The honest assessment: CrewAI is excellent for role-based workflow automation. The ceiling appears when your requirements grow past task-oriented workflows into continuous autonomous operation, P2P coordination, and deterministic cost governance. If you're building agents that need to run headlessly, persist across distributed systems, and enforce strict governance — you will hit that ceiling. TPipe is what comes next.

Migrating from CrewAI to TPipe

The migration is about shifting from role-based workflow composition to infrastructure-first agent design. You're not translating crew tasks to agent pipelines — you're restructuring how your agents think about state, coordination, and persistence.

Replace crew roles with capability registration

CrewAI's roles (researcher, writer, analyst) define agent behavior through role, goal, and backstory. TPipe's equivalent is P2PDescriptor capability registration — agents declare what they can do, not who they are. The agent identity shifts from a role description to a capability set.

Replace crew processes with orchestration patterns

CrewAI's Sequential process maps to TPipe's Pipeline chain — sequential pipe execution with validation boundaries. The Hierarchical manager pattern maps to TPipe's Manifold — a state-machine manager-worker pattern with cycle detection. Junction replaces the voting/consensus pattern if you need multi-agent agreement. DistributionGrid for cluster-wide P2P coordination.

Replace crew memory with ContextBank

CrewAI's crew-level memory is scoped to a single crew execution. ContextBank persists across runs, across distributed nodes. Every piece of state you were managing in crew memory becomes a ContextBank entry with weighted retrieval. No more starting each crew execution with empty context.

Replace manager delegation with P2P communication

CrewAI's manager is the communication hub — subordinates report to the manager, which delegates back. TPipe's P2P model has no dispatcher bottleneck. Agents discover each other by capability through the P2PDescriptor registry. Communication is direct, not through a manager. This requires rethinking how you coordinate — but it removes the single point of failure.

Add token governance and KillSwitch

CrewAI token management is at the crew level. TPipe's governance is two systems: token counting + truncation enforces memory budgets at the ContextWindow / LoreBook / MiniBank / Dictionary layer with TPipe-Tuner calibration per-model; KillSwitch is the separate safety net that throws an uncaught exception when accumulated tokens exceed a configured cap. Set it at the container level and it propagates through the hierarchy.

View Documentation Migration Guide →

Frequently Asked Questions

Is CrewAI easier to learn than TPipe?

CrewAI has a gentler learning curve for Python developers who think in terms of roles and workflows. The crew concept is intuitive — define agents with roles, assign tasks, run the crew. TPipe requires a different mental model: you're describing infrastructure, not composing workflows. If you're comfortable with Python and your use case fits the crew pattern, CrewAI is faster to get started with. If you need production-grade headless operation with strict governance, TPipe's learning curve pays off.

Can I use CrewAI and TPipe together?

Not a supported pattern. CrewAI is a Python framework with a specific mental model (roles, crews, processes). TPipe is an agent operating substrate with its own mental model (containers, pipelines, P2P). They have different runtime models and different orchestration primitives. Trying to compose them creates accidental complexity at the integration boundary. Choose the one that fits your architecture.

How does CrewAI's hierarchical process compare to TPipe's Manifold?

Both model manager-worker coordination, but the mechanisms differ. CrewAI's hierarchical process uses a manager agent that delegates tasks to subordinate agents and synthesizes results. The manager is itself an LLM-driven agent with a role. TPipe's Manifold is a state-machine manager-worker pattern with declarative pause/resume/jump at validation boundaries. The manager in a Manifold is a ManifoldInstance that controls the cycle (dispatch → process → evaluate → iterate or complete). It's a structured enforcement mechanism, not an LLM-driven agent. Which is right depends on whether you want LLM-driven delegation or structured state-machine control.

What about CrewAI's tool ecosystem vs TPipe's PCP?

CrewAI's tool integration uses Python decorators (@tool) — tools are Python functions that agents can call. The tool ecosystem is extensive because it's just Python. TPipe's PCP (Pipe Context Protocol) supports Stdio, HTTP, Python, Kotlin, JavaScript transports. Tools are PCP endpoints with JSON schema enforcement at every boundary. You can wrap any tool as a PCP endpoint, but CrewAI's Python-native tool integration is more straightforward for Python developers.

Why does TPipe require GraalVM Native Image for production?

Because Python cannot compile to a native executable. An agent substrate needs to run headlessly, at startup speed, on real infrastructure, without a Python interpreter overhead. TPipe's GraalVM Native Image gives a 50MB binary that starts in milliseconds, runs on ARM and embedded targets, and doesn't require a JVM at runtime. This is what production infrastructure demands. CrewAI requires a Python runtime — which adds overhead and limits deployment targets.

CrewAI has a cloud platform (CrewAI Studio) — how does that compare to TPipe's TraceServer?

CrewAI Studio is a cloud platform for monitoring and managing crews. It provides visibility into crew execution, task status, and agent performance. TPipe's TraceServer is self-hosted observability — no subscription, no data leaves your infrastructure. WebSocket streaming to a browser dashboard, every decision captured, indexed, replayable. The difference is deployment model: CrewAI Studio is SaaS (your data goes to CrewAI's servers), TraceServer is self-hosted (your data stays on your infrastructure).