As far as I know, nobody has yet written a routine to detokenize the output of the Axe input routine. I'm a bit surprised, because the routine is pretty easy to write. Below I have posted my implementation. It is rather large, because I just threw it together tonight and haven't optimized it at all. Maybe I will work on that tomorrow, maybe I won't. You could definitely shrink it by at least 10%---probably more like 30%---if you removed the local stack variables and did something more fancy.

UPDATE 14 January 2013: Fixed a bug in the Axiom, specifically a bug in the buffer overrun check. It was accidentally hard-coded for a fixed buffer size of 256 bytes because an arithmetic error. Also shaved two bytes off the routine.

Here's a sample program that just redisplays whatever you type in:
:.AA
:#Axiom(DETOKENI)
:input->A
:Detokenize(A,L1,128)
:Disp L1
Following is the readme.

====== Detokenize( =============================================================

    The Axe input command is small, but it returns data in the OS's tokenized
form.  As far as I know, there is no built-in system for limiting what the user
can enter.  The input command allocates a temporary variable in user memory to
hold the user's input.  This may or may not be an advantage for you.  The
temporary variable is a legitimate system variable, inasmuch as it has a VAT
entry and is length-prefixed.  However, the OS will automatically delete the
temporary variable for you when your program ends, so you do not need to worry
about leaking memory.

    The Detokenize( command uses the String>Eqn( token as its key.  The token is
located in the Catalog and is not in any other OS menu.  This routine is about
115 bytes.

    Detokenize( takes three arguments: The pointer returned by input, a pointer
to where you want to store your output, and the size of the output buffer.
Detokenize( does not return any status information.  If the detokenized string
cannot fit into the output buffer, the last full token that fit will be the last
token in the string.  The output is zero-terminated, which is what the Axe Disp
command expects.

    It is not safe to point make the output overwrite the input.  Many tokens
expand to more than one character, so the detokenized text could overwrite the
input token stream.

    Detokenize( can also be used to detokenize equations, strings, BASIC
programs, your Axe program's own source code, &c.


====== CleanAll() ==============================================================

    The input command creates a temporary variable in RAM.  This command uses
the CleanAll B_CALL to erase all temporary variables, including the one created
by input.  This is not necessary, but may be useful if you want to make sure the
RAM is free so you can do other things.

    The key for CleanAll() is ClearAllLists.  This routine is 3 bytes.


====== IsA2ByteTok( ============================================================

    This command is useful for parsing tokens yourself.  It returns 0 (false) if
the input byte is a one-byte token.  It returns 1 (true) if the input byte is
the first byte of a two-byte token.  The high byte of the input argument is
ignored.  This wraps the IsA2ByteTok B_CALL.

    The key for ISA2ByteTok( is Fpdf(, under DISTR.  This routine is 9 bytes.


====== Get_Tok_Strng( ==========================================================

    This command is useful for generating detokenized strings yourself.  It
calls the Get_Tok_Strng B_CALL to get the string for a particular token.  The
input is a POINTER to the token to get the string for.  Thus, if A points to the
token you are processing, you do Get_Tok_Strng(A) to get the string for A, not
Get_Tok_Strng({A}).  The string is stored into OP3 (address 848E in hex).  The
string is not zero-terminated.  Instead, this routine outputs the length of the
string.

    The key for Get_Tok_Strng( is Fcdf(, under DISTR.  This routine is 13 bytes.

Pretty neat. I wonder if it is possible to detokenize with the Axe strings instead of the default, though.

Nope, it is still in there.

Apparently it was quite buggy and never fixed, so most people made their own. I think it was finally never removed in case some people decide to use it anyway.

Fixed bugs in the sample program above and in the Axiom itself.

I don't believe so, but honestly, it's been so long that I can't recall. You'll just have to try it.