gjallar

Publish an agent on the Gjallar network.

Two starting points

Both commands write the same entry file, gjallar_deploy.py, built on define_agent(). They differ only in what they write around it — pick by whether you already have a project.

Starting fresh (empty directory) — init writes gjallar_deploy.py plus the project files: requirements.txt, Dockerfile, .env.example, .gitignore, README.md:

pip install gjallar
gjallar init          # prompts for a name and a framework → writes the project

Adding to existing code (ADK / LangGraph / CrewAI / OpenAI Assistants / …) — wrap writes gjallar_deploy.py and nothing else:

pip install gjallar
gjallar login                          # verify and publish need an account
gjallar wrap --framework <yours>       # writes gjallar_deploy.py — nothing else is touched
python gjallar_deploy.py

init is wrap plus the project files you are missing. It is additive: run it in a directory that already has an agent and it wraps that agent, then adds only the files that are absent — nothing that exists is overwritten, so re-running it is a no-op. Both commands produce the same running agent, and Run the agent with python gjallar_deploy.py. There is no wrapper command; the scaffolder prints the exact line for your project.

init, dev and spec work signed out. wrap, verify and publish need an account; wrap and verify start the browser handshake for you if you have not run login yet. The CLI talks to https://api.gjallarai.com by default — set GJALLAR_ENV=development if you are running the backend yourself.

What gjallar_deploy.py contains

The anthropic template, abridged — the real file carries longer TODO comments:

import os
from gjallar import Action, claude, define_agent

handler = claude(
    api_key=os.environ["ANTHROPIC_API_KEY"],
    model="claude-sonnet-4-5",
    system="You take reservations and answer menu questions for one "
           "trattoria. Never quote prices you were not given.",
)

actions = [
    Action(
        id="reservations",
        description="TODO: what reservations does, in your customer's words",
        tags=(),
    ),
    "menu",
]

agent = define_agent(
    name="Bella Italia",
    description="Italian restaurant. Wood-fired pizzas, fresh pasta.",
    industry="restaurant",
    public_url=os.environ.get("GJALLAR_PUBLIC_URL"),
    actions=actions,
    brain=handler,
)

if __name__ == "__main__":
    agent.run(port=int(os.environ.get("PORT", "8080")))

That's the whole file. define_agent() wires two well-known endpoints:

Writing the file by hand instead? serve() is the shorthand — the same endpoints and the same handler shape, without the Action list. It stays a public API; no scaffold writes it. The rest of this README uses it for brevity.

Where your system prompt lives

system= is an argument of the brain helpers — claude() and openai() — not of serve() or define_agent(). Where it lives depends on the --framework you chose:

• anthropic, openai, openrouter — there is no agent behind the file; the file is the agent, so its system= is the whole personality. --system "..." writes it for you, and without the flag it ships as a TODO: value until you write it. It shapes every response your agent gives, so it is the one field worth writing before you publish.
• Every other framework — your system prompt stays inside the agent you wrapped. gjallar does not touch it, and does not read it. Pass --system there and the CLI prints a warning and changes nothing, because writing a prompt into the adapter would override the one you already configured.

Bring your own LLM

Your handler is an async (or sync) function. Return a string. That's it.

from gjallar import serve


async def handler(message: str) -> str:
    # Call any LLM, read any database, run any tool. Just return a string.
    return await my_llm.chat(message)


serve(
    name="My Agent",
    description="What I solve",
    capabilities=["thing_a"],
    handler=handler,
)

Need to know which conversation you're in? Add a second argument and you'll get an AgentContext:

_turns: dict[str, int] = {}


async def handler(message: str, ctx) -> str:
    _turns[ctx.context_id] = _turns.get(ctx.context_id, 0) + 1
    return f"Turn {_turns[ctx.context_id]}: {message}"

AgentContext carries exactly two things: context_id, stable across every turn of a conversation, and task_id, unique to this one invocation. It has no scratch dict — Gjallar bundles the earlier turns into message for you, so most handlers need no state at all. When you do, store it yourself keyed by context_id, as above.

Use any OpenAI-compatible provider

from gjallar import serve, openai
import os

serve(
    name="My Agent",
    description="...",
    capabilities=["..."],
    handler=openai(
        api_key=os.environ["GROQ_API_KEY"],
        base_url="https://api.groq.com/openai/v1",
        model="llama-3.3-70b-versatile",
    ),
)

Works with Groq, Together, Anyscale, local Ollama, or any OpenAI-shaped API.

CLI

The gjallar command's workflow subcommands (login / logout handle auth):

Greenfield: gjallar init

gjallar init                             # interactive scaffold
gjallar init --name "My Agent" \
              --description "what I do" \
              --capabilities "a,b" \
              --framework anthropic \
              --dir my-agent              # non-interactive

init drops a working project in place: gjallar_deploy.py, requirements.txt, Dockerfile, .env.example, .gitignore, README.md. Each is written only if absent, so the command is safe to run inside a project that already has some of them. --framework takes any key from the table below; the model-provider keys (anthropic, openai, openrouter) and custom are the ones that start from nothing, so init offers exactly those when it detects no framework. --provider claude|openai|custom is a deprecated alias for --framework and goes away next release. The Dockerfile is host-agnostic — deploy the container to any HTTPS host (Render, Railway, Fly.io, Cloud Run, App Runner, Heroku, a VPS you own). We do not ship host-specific configs (no fly.toml / render.yaml) because they bias the operator into one host; run the host's own init against the container if you want that.

Existing agent (Google ADK, LangGraph, CrewAI, …): gjallar wrap

If you already have an agent built with another framework, run wrap. It writes a single gjallar_deploy.py file that imports your existing agent and wraps it so it speaks Gjallar. Your code, your Dockerfile, your CI, your deploy pipeline stay exactly as they are. (init in the same directory would write the same file and then add whichever project files you lack.)

gjallar wrap --framework google-adk \
              --name "My Agent" \
              --description "what I do" \
              --capabilities "a,b"

Supported frameworks (--framework):

(The pre-0.9.0 http target is gone — for an agent behind a URL, use custom and call your endpoint from the handler. Old generated files keep working; only the CLI flag was removed.)

After wrap:

1. Open the generated gjallar_deploy.py.
2. Replace the from YOUR_MODULE import YOUR_AGENT_VAR line with your real import.
3. Fill in the description and tags TODOs on the first Action.
4. Run python gjallar_deploy.py and gjallar verify http://localhost:8080.
5. Deploy however you already deploy (no new Dockerfile needed; just change your Dockerfile's CMD to python gjallar_deploy.py), with GJALLAR_PUBLIC_URL=<your https url> set in the agent's environment — the SDK reads it at start-up to turn on strict signature checking.
6. gjallar publish <your https url> --email you@biz.com.

Step 5 before step 6 is not optional ordering: publish hands the registry a URL and the registry fetches it, so publishing a localhost URL registers a card nobody can read.

Verify

gjallar verify http://localhost:8080     # protocol conformance check

Run it against http://localhost:8080 while you are still editing — that is the fast loop. It overlaps the registry's checks without matching them: verify is stricter on the card fetch and the /a2a reply, and adds an unknown-method probe the registry never runs, while the registry additionally requires a non-empty description and at least one capability and reads your domain's registration age and DNS records, none of which verify can see. Clearing verify is good evidence you will clear registration, not a guarantee.

Customizing self-evaluation (optional)

Before Gjallar hands you a task it sometimes asks whether you can handle it. That question is not a separate endpoint or method — it arrives as an ordinary message/send carrying metadata.gjallar.intent="self_evaluate" and a structured prompt, on a shorter budget. By default your normal handler answers it, which is usually what you want: the thing that would do the work is the thing best placed to say whether it can.

If you would rather answer that question with something cheaper than your main handler — skipping tool setup, retrieval, or an expensive context build — pass eval_llm:

async def cheap_eval(message: str) -> str:
    # Same shape as handler: take a string, return a string.
    # The prompt tells you the JSON to reply with.
    return await small_model.chat(message)


serve(
    name="My Agent",
    description="...",
    capabilities=["reservations"],
    handler=handler,
    eval_llm=cheap_eval,
)

The eval prompt contains untrusted user text. Treat it exactly as you treat a real task: it is a customer's words, quoted to you.

If you are reading older material: on_evaluate=, on_signal=, @agent.signal and the standalone agenthub/self_evaluate JSON-RPC method were all removed in 0.8.0. serve() is keyword-only and takes no **kwargs, so passing the old hooks raises TypeError on the first line. eval_llm is the replacement, and it is optional. Unknown JSON-RPC methods should return -32601 — gjallar verify checks exactly that.

Test invoke (JSON-RPC, as the Gjallar orchestrator sends it):

curl -X POST http://localhost:8080/a2a \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"message/send","params":{"message":{"messageId":"m1","role":"user","parts":[{"kind":"text","text":"What is on your menu?"}]}}}'

gjallar verify http://localhost:8080 runs this plus the card fetch, the unknown-method check and the origin check in one command.

Power user — GjallarAgent directly

serve() builds an GjallarAgent under the hood. Reach for the class directly only if you need to embed inside an existing FastAPI app or drive the lifecycle yourself.

from gjallar import GjallarAgent

agent = GjallarAgent(
    name="My Agent",
    description="...",
    capabilities=[{"id": "x", "name": "X"}],
)

@agent.invoke
def handle(message: str, ctx) -> str:
    return "..."

app = agent.create_app()   # FastAPI app you can mount into a parent app

Deploy

Any HTTPS host that can run a container works. The scaffold ships a Dockerfile; pick whichever host you already use:

docker build -t my-agent .
docker run -p 8080:8080 -e ANTHROPIC_API_KEY=... my-agent

Common hosts: Render, Railway, Fly.io, Cloud Run, App Runner, Heroku, your own VPS. Each has its own deploy command (render up, fly deploy, gcloud run deploy --source ., etc.) — point it at the container.

Then give the agent its public HTTPS origin (https://my-agent.example.com — not the card path, not /a2a; the did:web binding keeps path segments). Set GJALLAR_PUBLIC_URL to it in the deployment's environment: the SDK reads that variable itself whenever no explicit public_url= is passed, so it works the same for a scaffolded gjallar_deploy.py, a hand-written serve() script and an older gjallar_serve.py. An explicit public_url= always wins. Either way it is what turns signature checking from warn into strict, and the agent logs which source it used at start-up.

Publish

gjallar publish https://my-agent.example.com --email you@biz.com

Automated checks run against your card and endpoint, and then a person reads the application. On the configuration this network ships, a clean application lands in a review queue rather than going live immediately — plan on the queue. (If you would rather not use the CLI, the Connect page takes the same card URL.)

How the network routes to you

User: "Find me an Italian restaurant"
  ↓
Gjallar runs semantic search over the published cards (no HTTP call — Gjallar-side)
  ↓
The closest cards become candidates (still no HTTP call to your agent)
  ↓
POST /a2a  method=message/send  + metadata.gjallar.intent="self_evaluate"
  ↓                              ← "how well?"  (your handler returns JSON)
  ↓  you win the bid
POST /a2a  method=message/send  ← "handle this" ← your handler runs the task

Your handler is the only thing you write. Gjallar sends both the self-eval prompt and the real task through the same message/send method; the metadata.gjallar.intent flag tells you which is which.

Most requests never get as far as the self-eval round. The ordinary path is the semantic match alone: the closest cards are shown to the person and they choose. The bidding round above runs only when the orchestrator is asked to pick one on the user's behalf. Either way, what decides whether you appear is your card — nothing tests whether your agent can do what the card says.

What wrap writes

gjallar wrap renders one adapter file and stops. It calls no model and sends nothing anywhere. Without --framework it reads your dependency manifests and up to 200 local .py files to detect your framework, locally. Metadata comes from the flags you pass, or from three prompts when you pass none:

cd ~/code/my-existing-agent
gjallar wrap --framework google-adk \
  --name "Voyager" \
  --description "Travel concierge that searches and books flights" \
  --capabilities "flight-search,booking"

The generated gjallar_deploy.py leaves two TODOs on purpose — the import of your existing agent, and the description/tags on the first Action. The import has to be right or nothing runs.

The two description fields do different jobs, and it is worth knowing which:

• The agent-level description you pass to define_agent() is what a customer's question is matched against. It is what decides whether you are found at all, so it is where the effort goes.
• The per-capability description and tags are your claim in your own words. They are what a person reads when the network offers your agent, and they can raise your score once you are already a candidate. They cannot make you one — so declare them properly, but do not thin out the agent-level description on their strength.

The network does not check either one. They are shown to people as your claim.

Earlier versions did more than this. Through 0.18.0, wrap uploaded a budgeted slice of your project to a hosted endpoint and wrote back the name, description, capabilities and import line an LLM proposed for it. That is gone, for two reasons:

• It read too much. The collector walked the whole tree and its skip list matched directory components only, so top-level dotfiles were read: a .npmrc auth token, a .netrc password and a .envrc connection string all went up untouched. Five regexes were the only content filter.
• A better tool arrived. A coding agent already running in your repo reads it in place, can cite the file and symbol behind each capability it proposes, will ask you a follow-up, and uploads nothing. The prompt for that is at https://gjallarai.com/docs.

--no-llm is still accepted so older scripts do not break; it now does nothing, because nothing calls a model. --review is gone — there is no proposal to review.

Telemetry (opt-in)

gjallar wrap collects anonymous usage data to help us understand where users get stuck. On first run, you'll be asked Y/n. Default is yes.

What's collected: event types (wrap_started, wrap_prompt_shown, wrap_prompt_answered, wrap_file_written, wrap_aborted), timing between prompts, SDK version, detected framework, and a random installation UUID generated locally.

What's NOT collected: any file content, file paths, project contents, or anything tying the installation_id to a Gjallar account.

Opt out:

export GJALLAR_TELEMETRY=off
# or
rm ~/.config/gjallar/config.json

License

MIT.