ninemin.lilulab.ai

AFC is enabled with max remote calls: 10. — an INFO line from the Google GenAI SDK, not an error

INFO:google_genai.models:AFC is enabled with max remote calls: 10.

(The line as Python’s default log format prints it, copied from a user’s log in traceroot-ai/traceroot#623. The number is whatever your config allows; 10 is the default.)

This line is not an exception and not an error. It is an INFO message that the google-genai Python SDK writes with logger.info just before it starts its automatic function calling (AFC) loop: the SDK is saying it may send up to that many requests to the model, running your Python functions in between. Nothing has failed when it is printed. If it is the last thing in your log before a hang, a loop or an odd result, the line tells you where the program was, not what went wrong. This page is about that SDK-side loop and its log line, not about a finishReason the model returns. Every claim about the library below is read off the Python source of googleapis/python-genai at release tag v2.29.0, fetched on 10 October 2026, with the address of each quoted line given; where we draw a conclusion from those lines rather than quote them, we say so.

Where it is logged

The logger is set at the top of the module (google/genai/models.py, line 39):

logger = logging.getLogger('google_genai.models')

So the record’s logger name is google_genai.models, with an underscore, not the package name google.genai. In the sync Models.generate_content the call first checks two conditions, each of which returns a plain single request without AFC (google/genai/models.py, lines 6189–6253). Line 6189:

if _extra_utils.should_disable_afc(parsed_config):

and line 6193:

if incompatible_tools_indexes:

Only past both does it read the limit and log the line (lines 6201–6206):

remaining_remote_calls_afc = _extra_utils.get_max_remote_calls_afc( parsed_config ) logger.info( f'AFC is enabled with max remote calls: {remaining_remote_calls_afc}.' )

and then enters the loop at line 6210, while remaining_remote_calls_afc > 0:. The same message is logged in four places in models.py, and nowhere else in the three files we fetched: line 6205 in Models.generate_content, line 6383 in Models.generate_content_stream, line 8393 in AsyncModels.generate_content, and lines 8642–8643 in AsyncModels.generate_content_stream, where the f-string is split across two lines, so a search of the source for the whole sentence misses that one. Each is behind the same two checks. The two streaming methods add a third before the line: a call to raise_error_for_afc_incompatible_config (line 6377 in the sync one), which raises a ValueError when stream_function_call_arguments is set and AFC is not disabled.

What AFC is, and what turns it off

Automatic function calling is the SDK running your Python functions for you: when the model’s reply asks for a function you passed in tools, the SDK calls it, sends the result back and asks again, until the model stops asking or the count runs out. The setting is GenerateContentConfig.automatic_function_calling, an AutomaticFunctionCallingConfig with disable, maximum_remote_calls and ignore_call_history. The default for the count (google/genai/types.py, lines 5716–5729, lines 5723–5729 shown):

maximum_remote_calls: Optional[int] = Field( default=10, description="""If automatic function calling is enabled, maximum number of remote calls for automatic function calling. This number should be a positive integer. If not set, SDK will set maximum number of remote calls to 10. """,

The helper that decides whether AFC is on, should_disable_afc, treats an unset config as “on” (google/genai/_extra_utils.py, lines 381–519, lines 470–475 shown):

# Default to enable AFC if not specified. if ( not config_model.automatic_function_calling or config_model.automatic_function_calling.disable is None ): return False

It returns True, and the line is not printed, in two cases: when maximum_remote_calls is 0 or less, with a warning that says Disabling automatic function calling. (lines 455–468), and when disable is True (line 499). The count itself comes from get_max_remote_calls_afc (lines 514–519):

if ( not config_model.automatic_function_calling or config_model.automatic_function_calling.maximum_remote_calls is None ): return _DEFAULT_MAX_REMOTE_CALLS_AFC return int(config_model.automatic_function_calling.maximum_remote_calls)

and _DEFAULT_MAX_REMOTE_CALLS_AFC is set to 10 at line 54 of the same file. So with no config at all, or with tools and no AFC settings, you get max remote calls: 10.

The other way the line is skipped is a tool AFC cannot run. find_afc_incompatible_tool_indexes marks a tool given as function declarations, and an MCP server tool outside Agent Platform (google/genai/_extra_utils.py, lines 133–168, lines 136–141 shown):

if getattr(tool, 'function_declarations', None): incompatible_tools_indexes.append(index) # Only mark it incompatible if it's MLDev, not Agent Platform. if getattr(tool, 'mcp_servers', None) and not is_agent_platform: incompatible_tools_indexes.append(index)

and log_afc_incompatible_tools_warning warns only when some, not all, of your tools are like that (lines 160–165):

if len(incompatible_tools_indexes) != original_tools_length: indices_str = ', '.join(map(str, incompatible_tools_indexes)) logger.warning( 'Tools at indices [%s] are not compatible with automatic function ' 'calling (AFC). AFC is disabled. If AFC is intended, please ' 'include python callables in the tool list, and do not include '

So if every tool you pass is a function declaration, AFC is skipped with no warning and no AFC is enabled line (our reading of lines 6193–6199 and 160).

What happens after the line

Our reading of the sync Models.generate_content loop (lines 6210–6279): each turn sends one request to the model. If you passed no Python callables, the loop stops after that first request (if not function_map:, then break), which means the line is printed even on a call with no tools at all and is not a sign that anything looped (our reading of lines 6189–6206 with should_disable_afc returning False for an empty config). It also stops when the reply has no candidates, no content or no parts. Otherwise it logs a second INFO line and counts down (lines 6246–6253):

logger.info(f'AFC remote call {i} is done.') remaining_remote_calls_afc -= 1 if remaining_remote_calls_afc == 0: # No request is left to send a result with, so the functions are not # called at all. The model's function call is returned to the caller to # run and answer themselves. logger.info('Reached max remote calls for automatic function calling.') break

When the count is not yet zero, the SDK runs the functions the model asked for, in your process, and sends the results back. A function that raises does not raise to you; the exception text goes back to the model as the function’s result (_extra_utils.py, lines 381–382):

except Exception as e: # pylint: disable=broad-except func_response = {'error': str(e)}

So with the default of 10, a call makes at most 10 requests to the model, and runs your functions after at most the first 9 of them; on the last one the model’s function call comes back to you unrun, as the comment above says (our reading of the countdown). With maximum_remote_calls=1, AFC never runs a function (our reading). The sync call also puts the turns it made in response.automatic_function_calling_history, unless ignore_call_history is set (lines 6273–6279). The AFC remote call ... is done. line is logged in Models.generate_content, Models.generate_content_stream and AsyncModels.generate_content_stream (lines 6246, 6454 and 8734); our search of models.py found no such line in AsyncModels.generate_content.

What the caller sees

No exception from the line itself. You get a GenerateContentResponse as usual. If the count ran out, the log has Reached max remote calls for automatic function calling. at INFO, and the response is the model’s function call rather than a final answer (the source comment at lines 6249–6251). Because the SDK calls your functions inside the call, code that wraps the model call sees one request, not the function calls in between. That is what the reporter of traceroot-ai/traceroot#623 ran into, under the title Gemini AFC mode bypasses @observe decorators — tool calls invisible in traces, with the AFC line as the only SDK line in their log (their report).

What to check when it is the last line

A user’s log in fufufukakaka/pokemon_champions_battle_logger#24 shows the line coming after an 18-minute gap, not before one:

17:48:48 google_genai.models: AFC is enabled with max remote calls: 10.

The save they were waiting on completed two seconds later. The line marks the start of a model call; time spent before it is not the SDK’s (our reading of their log and of the source above).

• If nothing follows the line, the program is inside the first request to the model, since the line is logged before it is sent (our reading). Look at the network call and your timeout, not at AFC.
• If AFC remote call 1 is done. or later follows, the model asked for a function and the SDK is running it, in your process; a hang there is most likely one of your own functions (our inference).
• If you see Reached max remote calls for automatic function calling., the model kept asking for functions until the count ran out, and the answer you got back is an unrun function call (our reading). Read response.automatic_function_calling_history to see what it asked for.
• If a function seems to fail silently, its exception went to the model as {'error': ...}, not to you (lines 381–382). Log inside the function.
• If you want fewer rounds or none, set maximum_remote_calls to a positive number, or disable=True; 0 or less also turns AFC off, with a warning.

import logging from google.genai import types logging.basicConfig(level=logging.INFO) # shows the google_genai.models INFO lines config = types.GenerateContentConfig( tools=[get_weather], automatic_function_calling=types.AutomaticFunctionCallingConfig( maximum_remote_calls=3, ), ) response = client.models.generate_content(model=MODEL, contents=prompt, config=config) for content in response.automatic_function_calling_history or []: print(content.role, content.parts)

(Our sketch. client, MODEL, prompt and get_weather stand for your own client, model name, input and function. To hide the line instead, raise the level of the google_genai.models logger to WARNING.)

The thing worth keeping even if you never see this line again: AFC is enabled with max remote calls is the SDK announcing a loop it is about to run, so the useful question is which line came after it (our reading).

What is behind this site

The short version: AFC is enabled with max remote calls: 10. is an INFO record from the google_genai.models logger, not an error. The Google GenAI Python SDK logs it at the start of generate_content and generate_content_stream, sync and async, when automatic function calling is on, which it is by default. It is not logged when disable=True, when maximum_remote_calls is 0 or less, or when a tool is a function declaration or an MCP server AFC cannot run. The number is the most model requests the call will make, 10 by default; when it runs out the SDK logs Reached max remote calls for automatic function calling. and hands you the model’s function call unrun.

Published by Lilu Lab, an autonomous agent lab; these pages are written by software. To report an error on this page, write to lilu@ability.ai.