Tactet and LangChain

LangChain's frameworks are for building an agent, of any size. Tactet is for an enterprise running many small ones as one system: developers write them, and everyone else runs them from one search box. The two overlap in places, which is why the question comes up, but they start from different problems.

A Tactet agent is an independent unit built for a single task. Agents do not call other agents. Its limits are written down: which systems it may reach, how long it may run and how much it may spend on LLM calls. It is built to run thousands of times, for different users, quickly and at low cost.

"LangChain" is several products, and the difference is not the same for each:

  • The frameworks. LangChain, LangGraph and Deep Agents are open-source libraries for building an agent in Python or TypeScript. LangSmith is the platform for tracing, evaluating and deploying what gets built. LangGraph describes itself as a runtime for long-running, stateful agents, and Deep Agents as a harness for long-running agents on complex tasks. A Tactet agent is short-running and keeps its state in the conversation between runs, so these frameworks and Tactet are built for different kinds of agent.
  • LangSmith Fleet. A no-code product: anyone can create an agent by describing a task, then share it. Its goal is close to Tactet's, agents for a whole company, and its route there is different.

At a glance

TactetLangChain frameworksLangSmith Fleet
Starting pointAn enterprise running many small agents as one systemA developer building an agent in codeAnyone creating an agent without code
What an agent isOne task, with a written boundary on systems, time and cost; state lives in the conversationCode, of any size; the frameworks are built for long-running, stateful agentsInstructions, tools and its own memory
Who writes agentsDevelopersDevelopersAnyone, by describing the task
Who uses themEveryone in the enterpriseWhoever the application was built forThe creator, and the colleagues it is shared with
How a request reaches an agentSearch finds the agentThrough the application's own entry pointA person chooses the agent by name
What decides the stepsThe command list its developer wroteThe developer's code, the model, or a mixThe model
How agents combineThrough the conversation they shareIn code, by the developerEach agent has its own memory and threads

Who writes agents and who uses them

In Tactet these are different people. Developers write agents and publish them. Everyone else types what they need, and does not have to know which agents exist.

With LangChain's frameworks, a development team builds an agent application and owns all of it. Its users are whoever it was built for: the team itself, colleagues, or the company's customers.

With Fleet, an agent usually starts with the person who needs it. They describe a routine task in plain language and Fleet builds the agent. It can then be shared with colleagues, and a central team can publish one for the whole workspace to run (launch post).

How a request reaches the right agent

In Tactet, search decides. Every published agent carries a plain-language description of its task and its boundaries; a request is matched against all of them, and the best match runs. When nothing fits, search returns no agent instead of improvising an answer.

Agents written by different developers need no knowledge of each other. A follow-up in the same conversation can run a different agent, which reads what the previous one produced.

In LangChain, a developer or a person decides. An application built with the frameworks has its own entry point, and its developer decides which agents it contains and how work moves between them. LangChain documents patterns for that, including subagents, handoffs and a router.

In Fleet, each agent has a name and a person chooses it, in chat or by @mentioning its Slack handle.

What an agent is

In Tactet, an agent is one task: one verb, one or two systems, a run measured in seconds. A vacation request, an invoice status lookup, a meeting-room booking. Its definition is an ordered list of commands in JSON, with Python expressions: call an API, query a database, call a model, ask the person a question. The command list decides what runs next; the model is one of the commands, not the thing choosing them.

The definition is also the boundary. It names the profiles the agent may reach, so it reaches nothing else. It runs inside the agent runtime with no arbitrary code, and it stops at its time and LLM cost budgets. Because it has a small number of specific paths rather than an open-ended set, it is validated before publishing by a real run with every step traced, and the same request takes the same path on every run.

Like a microservice, an agent holds nothing on the server between runs. Its state, its own and what it shares with other agents, lives in the conversation, saved when a run ends or pauses and restored for the next run. The state is per conversation: another conversation cannot see it, and a conversation belongs to one user, so another user cannot see it either.

In LangChain's frameworks, an agent is code, with the whole language available, and nothing limits what one agent is. The frameworks are built for the large end: LangGraph for long-running, stateful agents that persist through failures and resume where they left off, Deep Agents for complex tasks, with planning, subagents, a virtual filesystem and context management. With create_agent and Deep Agents, a model works in a loop and chooses the next tool. With LangGraph, the developer lays out a graph and decides which steps are fixed code and which are left to the model.

The kinds of agent the Tactet agents page sets aside, a general assistant that takes any question, or an analysis workbench whose cost and reach are not known in advance, are the kinds these frameworks are made for.

In Fleet, an agent is instructions, tools and its own memory, and the model decides the steps on each run. Its scope is whatever its description says, and there is no fixed path to validate.

How agents work together

In Tactet, through the conversation. Agents do not know about each other. What one agent produces, its prompt history and the conversation's variables, is there for the next agent that runs in the same conversation, even one using a different model, because the shared prompt history does not depend on the model. A follow-up question runs whichever agent fits it, and that agent reads what the previous one left behind. Two agents continue the same exchange with the model when their prompts share a name and the conversation scope; see Prompts.

In LangChain, in code. The developer decides which agents an application contains and how work moves between them. The documented patterns are subagents, where a main agent calls the others as tools; handoffs, where agents transfer control to each other; a router, where a classification step sends the request to one or more agents; and custom workflows in LangGraph.

In Fleet, each agent has its own identity, memory and threads. Agents sharing a conversation is not something its documentation describes.

Choosing between them

That depends on the agent.

LangChain's frameworks fit when:

  • the agent is one application, such as a customer-facing assistant or a coding agent, and you want full control in code
  • the work is open-ended, such as a general assistant that takes any question: the model decides which tools to call and how many steps to take, so a run's cost and reach are not known in advance
  • you need to score its output against datasets (LangSmith Evaluation)

Fleet fits when the people who need an agent should create it themselves, without a developer.

Tactet fits when:

  • the enterprise will have many small agents, written by different developers, and people should reach all of them from one place
  • each task has a boundary you can write down, which systems, how long, how much model spend, and should run the same way every time within it
  • a task will run thousands of times for different users, and each run should be recorded and reported by agent and by user
  • developers should spend their time writing agents, not building the routing, state, versioning and reporting around them

Using both

The two can be used together. A large agent built with LangChain can hand its bounded tasks to Tactet agents, and a Tactet agent can call a deployed LangChain agent. They connect through standard interfaces, in both directions.

  • LangChain calling Tactet. Tactet's REST API lets any program search for an agent and run it. An agent built with LangChain or LangGraph can call it as a tool, the way the Tactet skill does for an agent harness.
  • Tactet calling LangChain. A Tactet agent can call REST APIs and MCP servers. LangSmith's Agent Server exposes each deployed agent as an MCP tool and through its own REST API.

Sources

LangChain statements were checked against LangChain's own pages on October 3, 2026. Tactet statements come from the Tactet agents page, read on October 26, 2026, the Prompts page, read on October 20, 2026, and the rest of the Tactet documentation.