Instant Expert for agent frameworks

Let your agent pay a specific person for an answer. Instant Expert finds the executives, operators and domain experts an agent needs (or takes the ones it names), sends each a paid invitation for a short call or a written answer, and charges only if they book or answer.

Most human-in-the-loop tools route a question to your own team. Instant Expert routes it to the right stranger: the VP of Sales at a Series A fintech, the claims director at a mid-size insurer, the founder who already solved your problem. Your agent sets what each person receives and a total budget; the fee is added on top and charged only when someone accepts.

Everything here starts in test mode: no account, fictional people, recorded email and a Stripe test card, so you can run the whole flow in a minute.

Framework	Python (the framework's own MCP client, no package from us)	JavaScript (npm)	Example
LangChain	langchain.mcp (pip install "langchain[mcp]")	langchain-instant-expert	examples/langchain
CrewAI	MCPServerHTTP in Agent(mcps=[...]) (pip install crewai)	(CrewAI is Python only)	examples/crewai
OpenAI Agents SDK	MCPServerStreamableHttp (pip install openai-agents)	instant-expert/openai-agents	examples/openai-agents
Composio	Register the server as a custom toolkit		examples/composio
Any other MCP client	Streamable HTTP at the addresses below	instant-expert (core helpers)	Connect over MCP

Every framework here already speaks MCP, so Python needs nothing from us: point the framework's MCP client at Instant Expert with a bearer token. The two npm packages stay thin. They point the framework's own MCP client at Instant Expert with the right credential, hand you the server's workflow instructions for the system prompt (framework adapters drop them), and add one wait_for_job tool that polls in plain code, so a search that runs for minutes doesn't use up your agent's turns. The Python examples do the same few things in their own code.

Quickstart (test mode, no account)

Get a free sandbox token. It lasts 24 hours and reaches only fictional people:

export INSTANT_EXPERT_SANDBOX_TOKEN=$(curl -s -X POST https://instant.expert/api/sandbox | python3 -c 'import json, sys; print(json.load(sys.stdin)["token"])')
export OPENAI_API_KEY=...

Python, with the OpenAI Agents SDK (pip install openai-agents):

import asyncio
import os

from agents import Agent, ModelSettings, Runner
from agents.mcp import MCPServerStreamableHttp


async def main() -> None:
    server = MCPServerStreamableHttp(
        name="instant_expert",
        params={
            "url": "https://instant.expert/mcp/test",
            "headers": {"Authorization": f"Bearer {os.environ['INSTANT_EXPERT_SANDBOX_TOKEN']}"},
            # Some tools take 10 to 20 seconds; the SDK waits 5 by default.
            "timeout": 120,
        },
        client_session_timeout_seconds=120,
        # Pause the run before the paid send, so a person approves the order.
        require_approval={"send_requests": "always"},
    )
    async with server:
        agent = Agent(
            name="Expert finder",
            # The SDK keeps the server's instructions but doesn't show them to the model.
            instructions=server.server_initialize_result.instructions,
            mcp_servers=[server],
            # One tool call per turn, so the model reads results before drafting.
            model_settings=ModelSettings(parallel_tool_calls=False),
        )
        result = await Runner.run(
            agent,
            "Find 3 VPs of Sales at B2B software companies and draft a $40 "
            "offer each for a 15-minute call, $150 total budget.",
            max_turns=30,
        )
        print(result.final_output)


asyncio.run(main())

LangChain (pip install "langchain[mcp,openai]", LangChain 1.4 or newer). The MCP tools are async, so run the agent with ainvoke:

import os

from fastmcp import Client
from langchain.agents import create_agent
from langchain.mcp import MCPAdapter


async def build_agent():
    client = Client(
        "https://instant.expert/mcp/test",
        auth=os.environ["INSTANT_EXPERT_SANDBOX_TOKEN"],
        timeout=120,
    )
    async with MCPAdapter(client) as adapter:
        tools = await adapter.list_tools()
        # The adapter doesn't pass the server's instructions to the model.
        instructions = adapter.client.instructions
    return create_agent("openai:gpt-5.4-mini", tools=tools, system_prompt=instructions)

On an older LangChain, langchain-mcp-adapters works the same way: MultiServerMCPClient({"instant_expert": {"transport": "streamable_http", "url": "https://instant.expert/mcp/test", "headers": {"Authorization": f"Bearer {token}"}}}), then await client.get_tools().

CrewAI (pip install crewai):

import os

from crewai import Agent
from crewai.mcp import MCPServerHTTP

researcher = Agent(
    role="Expert network researcher",
    goal="Get answers from the right executives",
    backstory="You find people through Instant Expert and only spend within budget.",
    mcps=[
        MCPServerHTTP(
            url="https://instant.expert/mcp/test",
            headers={"Authorization": f"Bearer {os.environ['INSTANT_EXPERT_SANDBOX_TOKEN']}"},
        )
    ],
)

JavaScript: langchain-instant-expert and instant-expert on npm get and cache the sandbox token for you.

The examples run the full loop: find people, draft the ask, pause for your approval, send on the test card, and report who booked, replied or declined. Each one puts its framework's own approval step in front of the paid send.

What test mode is

Test mode is the endpoint https://instant.expert/mcp/test with an anonymous sandbox token from POST https://instant.expert/api/sandbox. In Python that's one request (above); the JavaScript packages get and cache the token for you.

• Searches return about 300 fictional people at fictional companies, instantly and for free. Their emails are on the reserved .example domain.
• No email is sent. Each invitation is recorded and shown by get_request.
• Orders use a Stripe test card that's attached for you. Holds, charges and refunds run in Stripe's test environment.
• Each fictional person responds on their own after delivery: they book, reply, decline, never answer, or bounce. simulate_response forces an outcome, including call_completed to see the payout.
• Every response carries test_mode: true.

A sandbox lasts 24 hours, and each network can create five sandboxes an hour, so reuse one token across runs (the Python examples use INSTANT_EXPERT_SANDBOX_TOKEN when it's set). A sandbox remembers its requests, and nobody is invited twice while a request to them is open, so if you rerun a demo and the agent finds nobody left to invite, start a fresh sandbox: a new token in Python, or INSTANT_EXPERT_NEW_SANDBOX=1 for the JavaScript packages. Test mode has the same per-account limits as live, for example 5 searches a minute, 20 an hour and 50 a day (all limits).

Going live

A real account uses https://instant.expert/mcp, and the switch is explicit in code:

Route	Test mode (default)	Real account
LangChain, Python	Client("https://instant.expert/mcp/test", auth=token)	Client("https://instant.expert/mcp", auth="oauth")
OpenAI Agents SDK, Python	"headers": {"Authorization": f"Bearer {token}"}	"auth": OAuth(mcp_url="https://instant.expert/mcp") (fastmcp.client.auth)
CrewAI	MCPServerHTTP(url=".../mcp/test", headers=...)	MCPServerHTTP(url="https://instant.expert/mcp", headers=...) with an access token
LangChain.js	new InstantExpertToolkit()	new InstantExpertToolkit({ testMode: false, token })
OpenAI Agents SDK, JavaScript	instantExpertServer()	instantExpertServer({ testMode: false, token })

How sign-in works today:

• The live server accepts OAuth 2.1 access tokens only. There are no API keys yet. Each connection is a separate grant that you can revoke in Connected assistants.
• In Python, FastMCP's standard OAuth client signs in for you (pip install fastmcp; langchain[mcp] already includes it). The first run opens your browser to sign in and approve the connection. FastMCP keeps the tokens in memory unless you give its OAuth helper a token store, so without one each new process signs in again.
• CrewAI and the JavaScript packages send an access token you supply (token, or the INSTANT_EXPERT_TOKEN environment variable for the npm packages). Access tokens expire after a short time and there's no command to print one yet, so for now the FastMCP sign-in (LangChain or the OpenAI Agents SDK in Python) is the practical way to use a real account.
• To place paid orders, the connection also needs Allow paid requests from this assistant turned on (a checkbox when you approve it, or later in Connected assistants), and the account needs a saved card (Account and payment). Without both, the agent prepares drafts and you send them yourself from Requests.

Safety

• Nothing is sent or charged until send_requests, and the server requires an order preview (prepare_request_order) and its confirmation token first.
• The examples put a person in front of every paid send: require_approval in the Python OpenAI Agents SDK, HumanInTheLoopMiddleware in LangChain, a before_tool_call hook in CrewAI, and for the JavaScript OpenAI Agents SDK, a first pass with allowSend: false that can't send at all.
• Names, bios and replies come from third parties. The server's instructions tell the model to treat them as information, never as instructions.

Tools

The server's tools come through each framework unchanged: plan_outreach, search_people, import_people, queue_requests, get_job, get_search, list_searches, get_request_draft, prepare_request_order, send_requests, get_request_order, list_requests, get_request, and simulate_response in test mode. The npm packages and the Python OpenAI Agents and LangChain examples add wait_for_job. CrewAI prefixes each tool name with the server, for example instant_expert_mcp_test_send_requests. Full reference: instant.expert/docs/mcp.

Python wrappers (optional, not on PyPI)

The python/ folder has thin Python wrappers that match the npm packages: instant-expert (sandbox-token caching, the server's instructions, a wait_for_job helper, the OpenAI Agents SDK server and a browser sign-in that saves tokens on disk), langchain-instant-expert and crewai-instant-expert. You don't need them: everything above works with the frameworks alone. They aren't published on PyPI, so install one from GitHub, together with the core package it depends on:

pip install "instant-expert[openai-agents] @ git+https://github.com/Instant-Expert/integrations#subdirectory=python/instant-expert"

pip install "git+https://github.com/Instant-Expert/integrations#subdirectory=python/instant-expert" \
  "git+https://github.com/Instant-Expert/integrations#subdirectory=python/langchain-instant-expert"

pip install "git+https://github.com/Instant-Expert/integrations#subdirectory=python/instant-expert" \
  "git+https://github.com/Instant-Expert/integrations#subdirectory=python/crewai-instant-expert"

A framework wrapper on its own fails to install, because pip looks for instant-expert on PyPI; naming the core's GitHub address in the same command satisfies it.

Development

Tests call the public test-mode server, so they reach no real people and spend no money. Set INSTANT_EXPERT_OFFLINE=1 to run only the offline ones.

# Python: one virtual environment per framework, since their pins conflict
cd python/instant-expert && pip install -e ".[openai-agents,test]" && pytest
cd python/langchain-instant-expert && pip install -e ../instant-expert -e ".[test]" && pytest
cd python/crewai-instant-expert && pip install -e ../instant-expert -e ".[test]" && pytest

# JavaScript (Node 24 runs the TypeScript tests directly)
cd js && npm install && npm run build && npm test

License

MIT