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 LangGraph

Not the same thing. Not even in the same category.

Category Agent Operating Substrate vs Graph Orchestration Library

Multi-Agent Model 3 patterns: P2P, manager-worker, voting vs Graph nodes with conditional edges

Agent Discovery Registry-based P2P — built in vs External service mesh required

Long-Horizon Hundreds of millions of tokens — proven vs Context degrades without manual management

What LangGraph Actually Is

LangGraph is LangChain's multi-agent orchestration layer. It extends LangChain's LCEL (LangChain Expression Language) with a graph-based model where agents are nodes and edges define transitions. You program conditional logic at each node to determine what happens next.

This is genuinely useful for a specific problem: chatbots with branching conversations where you need explicit control over what flows where. If you're building a customer service bot with 20 possible paths, LangGraph's graph model maps cleanly to that.

TPipe is not a graph orchestration library. It's an agent operating substrate where agents run inside a persistent environment with built-in P2P discovery, thread-safe memory, token governance, and orchestration patterns that don't require you to program every conditional yourself.

The comparison matters because LangGraph is often cited as the "serious production" option in the LangChain ecosystem. If you're evaluating it for multi-agent production systems, you should understand what you're choosing between.

Architecture Comparison

Category

What it actually is

Agent Operating Substrate

Infrastructure your agents inhabit

Graph Orchestration Library

Extension of LCEL for multi-agent flows

Multi-Agent Patterns

What coordination models it supports

Three distinct patterns: Manifold (state-machine manager-worker), Junction (voting/handoff between pipelines), DistributionGrid (cluster-wide P2P). Each handles a different coordination topology. You're not forced into one model.

Graph nodes with conditional edges. All agents are nodes in a directed graph. You define state transitions with conditional logic. The pattern is always the same structure — nodes and edges — regardless of use case.

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. No dispatcher bottleneck. Agents discover each other by capability, not by pre-defined graph edges.

No native P2P. Agents communicate via graph edges — the connection must be explicitly defined in the graph structure. Agent-to-agent communication requires external service mesh (Kubernetes service discovery, etc.) or custom implementation. The graph doesn't provide discovery, just routing.

Memory Model

How state persists

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

Checkpointer + store. LangGraph Checkpointer persists graph state to save snapshots via an in-memory defaultdict by default (MemorySaver/InMemorySaver). For production persistence you need langgraph-checkpoint-postgres (PostgresSaver). Store provides key-value persistence. State survives restarts within the checkpointer's configured backend. Cross-session persistence requires external database. No native weighted retrieval.

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. No forced termination in LangGraph — retry handlers absorb failures.

Retry policies + LCEL. LangGraph uses standard LangChain retry configurations. Errors can be caught at node boundaries. No forced termination mechanism — retry handlers can absorb failures and continue silently.

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. Today TPipe runs as java -jar TPipe-*.jar on JVM 24 — GraalVM Native Image ships separately.

Python runtime required. LangGraph is a Python library — requires Python interpreter. Typically runs as a Python service or containerized with Python inside. Not headless-native — designed for chatbot applications with API endpoints.

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.

MessageGraph state. Messages accumulated in graph state. Truncation via trim_messages or manual management. Context degrades past 30–50 turns without explicit truncation strategy. No automatic lorebook injection.

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 — you control what the model focuses on and when.

Prompt engineering + LCEL. System prompts and few-shot examples in node definitions. LLM thinks however it wants within the prompt constraints. No structured reasoning enforcement. Reasoning mode available via LangChain's internal models where supported.

Fault Tolerance

What happens when something fails

Snapshot-based state restoration. Parent pipe failure propagates recursively to child pipes. KillSwitch forced termination (uncaught exception, propagates through container hierarchy). Manifold Loop Limit throws ManifoldLoopLimitExceededException. TraceServer is a separate module with REST + WebSocket dashboard and dual auth. State can be restored from last valid snapshot.

Node-level retry. Errors caught at node boundaries. Graph continues from last successful node. No automatic state restoration — state is recovered from checkpointer snapshots. No forced termination on infinite loops without explicit configuration.

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.

LangSmith (paid SaaS) or LangChain's built-in tracing callbacks. No native self-hosted observability without LangSmith subscription. Debugging via callback logging and LangGraph's built-in visualization.

When to Choose TPipe Over LangGraph

TPipe is the better choice when:

Your multi-agent topology isn't a graph. If agents need to discover each other dynamically, coordinate peer-to-peer without pre-defined edges, or form ad-hoc collaboration patterns — a graph with explicit edges doesn't support that. P2P does.
Headless operation is a requirement. LangGraph is designed for chatbot applications with API endpoints. TPipe is designed for headless processes that run continuously on server infrastructure. If your agents need to run in the background without a chat interface, TPipe's headless-first design fits that model.
Long-horizon task survival is 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. If you're building agents that need to run for days, TPipe's ContextBank persistence handles that without manual intervention. LangGraph's message accumulation requires manual truncation past a certain point.
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. LangGraph's retry handlers can absorb token overruns and continue running — which is the opposite of cost control.
You're deploying to non-x86 infrastructure. GraalVM Native Image runs on ARM, Android, iOS, embedded targets. Python libraries like LangGraph don't ship as native binaries.

When LangGraph Is the Right Choice

LangGraph is the right choice when:

Your use case maps cleanly to a graph. If you have a fixed number of states, explicit transitions, and you need visual clarity on how conversations flow — LangGraph's graph model is a natural fit. Customer service bots, routing systems, decision trees.
LangChain ecosystem integration matters. If you're already deep in the LangChain tool ecosystem and need multi-agent orchestration that composes with existing chains and tools — LangGraph extends that ecosystem rather than replacing it.
Rapid prototyping with visual debugging. LangGraph Studio provides a visual interface for debugging graph flows. If you need to iterate fast and see the graph structure visually, LangGraph's developer experience is strong.
Your team knows Python and doesn't have a GraalVM/kotlin background. LangGraph is a Python library with extensive documentation, community examples, and LangChain integration. TPipe requires a different mental model and (currently) Kotlin or Java familiarity.

The honest assessment: LangGraph is an excellent graph orchestration library for chatbot applications. TPipe is an agent operating substrate for production infrastructure. The comparison only makes sense because both are positioned as "multi-agent solutions" — but they solve fundamentally different problems in fundamentally different ways.

Migrating from LangGraph to TPipe

The migration is not about translating graph edges to pipeline stages. It's about switching from an explicit graph programming model to a declarative container model where enforcement happens at validation boundaries.

Replace graph nodes with Pipelines + containers

LangGraph's nodes are explicit code units in a directed graph. TPipe's equivalent is a Pipeline with Pipe subclasses at each stage. The difference: TPipe's validation happens at enforcement boundaries, not at arbitrary callback points. Map your graph's node logic to a pipeline chain, then use pauseWhen for declarative gates.

Replace conditional edges with Junction

LangGraph routes between nodes with conditional edge functions. TPipe's Junction is a democratic multi-participant discussion harness — participants vote on outcomes, not edges. Use Junction when you need consensus (planner/actor/verifier pattern). Use Manifold for manager-worker dispatch. Use DistributionGrid for cluster-wide P2P. Three patterns, not one.

Replace Checkpointer with ContextBank

LangGraph's Checkpointer (MemorySaver by default) stores snapshots in memory — production needs PostgresSaver. ContextBank is persistent by default across distributed nodes, with weighted LoreBook retrieval, substring-triggered activation, and token-budget-aware injection. No external database required for persistence. No snapshot reload on restart.

Add KillSwitch for hard cost enforcement

LangGraph has no forced termination — retry handlers can absorb token overruns silently. TPipe's KillSwitch throws an uncaught exception that propagates through the entire container hierarchy (Pipeline, Manifold, Junction, DistributionGrid, Splitter, Connector, MultiConnector). Set it at the container level and it flows down. This is the hard stop LangGraph doesn't have.

Replace LangSmith with TraceServer

LangSmith is a paid SaaS product with tracing callbacks. TraceServer is self-hosted observability — REST + WebSocket dashboard, every decision captured, indexed, replayable, dual auth (agent bearer + client session). No subscription, no data leaves your infrastructure.

View Documentation Migration Guide →

Frequently Asked Questions

Can I use LangGraph and TPipe together?

Not a supported pattern. LangGraph is a Python library and TPipe is a GraalVM substrate. They have different runtime models, different memory architectures, and different orchestration primitives. Trying to compose them creates accidental complexity at the integration boundary. If you're evaluating both, choose the one that fits your architecture. If you need TPipe's capabilities, use TPipe. If LangGraph's graph model fits your problem, use LangGraph.

LangGraph has P2P features through LangChain's LangGraph Platform — isn't that the same as TPipe's P2P?

No. LangGraph Platform's "P2P" refers to horizontal scaling of LangGraph instances — multiple replicas of the same graph running in parallel. This is load balancing, not peer-to-peer agent discovery. TPipe's P2P is registry-based discovery where agents find each other by capability, not by pre-configured graph edges. The terminology overlap is unfortunate — the capabilities are completely different.

What about LangGraph's infinite loop protection vs TPipe's Loop Limit?

LangGraph has recurrence limits on the graph walker — max iterations before the walker terminates. TPipe's Manifold Loop Limit is a fail-safe mechanism that throws ManifoldLoopLimitExceededException after configured iterations (default 100). Manifold only — Junction and DistributionGrid do not have an equivalent iteration cap. Both prevent infinite loops, but TPipe's is enforced at the substrate level with forced termination. LangGraph's depends on how you've configured the graph and whether error handlers suppress the limit trigger.

Does TPipe's Manifold replace LangGraph's graph model?

No. Manifold is a state-machine manager-worker pattern. LangGraph is a graph orchestration library. They handle different coordination topologies. Manifold is for cases where a manager dispatches to workers, cycles until pass or terminate, and manages context truncation. LangGraph is for cases where you need explicit conditional edges between nodes. If your problem fits a graph, use LangGraph. If it fits manager-worker or P2P, use TPipe. If it fits both, you need to decide which model actually describes your problem.

Why does TPipe not have a visual graph editor like LangGraph Studio?

Because TPipe is not a graph orchestration library. Graphs are visible and debuggable when the mental model is nodes and edges. TPipe's orchestration primitives — Pipeline, Manifold, Junction, DistributionGrid — don't map cleanly to a visual graph representation. The TraceServer dashboard provides execution traces and debugging, but the programming model is declarative code, not visual graph composition. This is a deliberate choice: TPipe is designed for engineers who write code, not business users who drag nodes onto a canvas.

My team is comfortable with LangChain and LangGraph — why would we switch to TPipe?

You wouldn't switch for familiarity. You'd switch when LangChain's architectural ceiling starts causing problems: memory that doesn't persist across runs, cost governance that can be bypassed, multi-agent coordination that requires external service mesh, or deployment requirements that Python can't cleanly support. The migration from LangGraph to TPipe is harder than from LangChain because you're not just translating code — you're restructuring how your system thinks about state and coordination. If you're hitting LangChain's limits, TPipe is what comes next. If you're not hitting those limits, stay with LangGraph.