Agent framework integration

Twin Browser + AutoGen

AutoGen is Microsoft’s framework for multi-agent LLM applications — conversable agents that call registered functions and coordinate to complete a task. Functions registered with an agent become callable tools the model can invoke during a conversation.

Get an API key Read the docs

Agent framework3 MCP tools: run · compile_skill · run_skillBearer key auth

How Twin plugs into AutoGen

Twin’s AutoGen adapter registers a browser function on your assistant agent. When the model decides it needs the web, it calls the function with a goal and Twin executes it on the compile-once execution layer. The cross-tenant skill corpus means a skill compiled by one workflow can be safely reused by another, so the cache hit rate — and the savings — climb as the network runs.

Twin is the browser execution layer your stack calls. The first run cold-compiles a skill; every similar request after that is matched from the cache and replayed deterministically, so your marginal cost per run trends toward zero.

app.example.com

AutoGen → Twin

Receive goal from AutoGendone
Compile DOM → token-efficient indexed statedone
Match the semantic dispatch cacherunning
Replay compiled skill — 0 LLM callsqueued

What you get through AutoGen

Every integration is a thin wrapper over the same execution layer, so the cache, replay, and corpus benefits apply no matter how you call in.

Semantic dispatch cache

A re-phrased goal fuzzy-matches an already-compiled skill, so most calls never touch the LLM.

Deterministic replay

A compiled skill replays the exact action path with zero LLM calls — fast, repeatable, cheap.

Cross-tenant skill corpus

A skill compiled once can be safely reused across tenants, so the hit rate climbs as the network runs.

One Bearer key

Auth, usage-based billing, and an audit log run on every call — the same key works from every integration.

Wire it up

Drop Twin into AutoGen

Copy, paste, and swap in your Bearer key. The first run compiles a skill; repeats hit the semantic dispatch cache and replay deterministically.

AutoGen — register a browser functionpython

from autogen import AssistantAgent, UserProxyAgent
from twin_browser.autogen import register_twin

assistant = AssistantAgent("assistant", llm_config=llm_config)
user = UserProxyAgent("user", human_input_mode="NEVER")

# Registers a 'twin_run(goal, url)' function the assistant can call.
register_twin(assistant, user, api_key="tw_live_xxx")

user.initiate_chat(
    assistant,
    message="Pull this month's usage from the vendor dashboard and summarize it",
)

Base URL https://twin-browser.com/api/v1 · auth Authorization: Bearer tw_live_… · MCP tools run, compile_skill, run_skill.

Read the AutoGen docs API reference

Get started

Connect AutoGen in 4 steps

Install → configure your key → make the first call. The cache takes over from there.

1
Install the adapter
pip install twin-browser includes the AutoGen helper.
2
Register the function
Register twin_run on your AssistantAgent and UserProxyAgent.
3
Authenticate
Pass your TWIN_API_KEY to the adapter constructor.
4
Start the chat
Kick off the conversation; the agent calls twin_run when it needs the browser.

Why this stays cheap at scale

Most browser infrastructure re-runs the LLM on every execution, so cost climbs with usage. Twin compiles a task once via skill compilation, matches re-phrased requests to it, and replays without the model — so repeated workflows stop scaling with your token bill.

FAQ

AutoGen on Twin — common questions

Can multiple AutoGen agents share Twin skills?

Yes. Skills are compiled at the tenant level, so every agent in your workflow reuses them — and the cross-tenant corpus extends that benefit across the network where a skill is safe to share.

Does Twin handle login and MFA inside an AutoGen run?

Yes. Credentials live in the encrypted vault, and a step that needs approval or MFA triggers a human-in-the-loop handoff, then the run resumes.

Go deeper

REST API reference MCP server Docs Semantic dispatch cache Deterministic replay Credential vault Compare browser tools

LangChain

Agent framework

LangChain is a Python and JavaScript framework for building LLM applications — chains, agents, and tools. Its agent loop lets a model pick a tool, observe the result, and decide the next action, which makes browser access a natural tool to add.

OpenAI

LLM provider

OpenAI’s API supports function (tool) calling: you describe a function as a JSON schema, the model decides when to call it, and your code executes it and returns the result. This is the standard way to give a GPT-class model access to an external capability.

REST API

API

Twin’s REST API is the universal integration path: a small set of HTTPS endpoints under `/api/v1/*` authenticated with a Bearer key. Any language that can make an HTTP request can drive the browser execution layer — no SDK required.

Wire up AutoGen in minutes

Free to start. Usage-based credits from $29/mo, with LLM cost metered and passed through at 1×.

Get an API key See pricing