Is it possible for two independent people to generate randomness? It is well documented that people are not very good at generating random sequences. However, is it possible that two people, working independently, could generate randomness together? Consider the following two examples:
Example 1
My wife and I can't decide where to go to dinner, and we've narrowed it down to two options. Neither of us has a coin to flip, so we decide on this: My wife will choose a number between 1 and 1000. I will choose, privately, that we will go to Option A if her number, say, ends in an odd number. If she is unaware of my choice, and I am unaware of hers, will our selection be random?
Example 2
We need to randomly select a name from a list of length n. Person 1 decides on an order for the names: perhaps ordering alphabetically by the second letter of the last name. Person 2 "randomly" chooses a number from 1 to n. Would that selection be random?
 A: First of all, randomness is maybe the wrong word. What you are looking for is a random variable whose outcome it is very hard to predict. This can be formalised with the notion of entropy, but talking about predictability will make this more illustrative, I think.
Now, think of a third person observing what you are doing. Only if that third person is not able to predict the outcome of your draw better than a uniform distribution (Example 1) you can say it is "really random".
There might be many patterns that a third person might exploit: e.g. he has a distribution over your wife's favourite numbers and knows that you pick "odd" instead of "even" 60% of the time. This will help him to narrow down the possibilities.
I guess what you want is that the two of you can simulate a fair coin toss, without one of you gaming the system. Nevertheless, both of you have a deterministic way of picking a number. Let's assume both of you pick 0 or 1, which are then combined with XOR to form a final outcome. As long as one of you has a method to draw a 1 that the other cannot predict, I believe you will have a coin toss that cannot be gamed.
Let's assume you want to game the system, but you do not know whether your wife is going to pick 0 or 1 -- both have a probability of .5, ie. $p(w=1) = p(w=0) = .5$. Let us say you want $h \times w$, where $\times$ depicts XOR, to be $1$ and are free to pick $h$. But no matter how you pick $h$, $p(w \times h = 1) = .5$. So you cannot game the system.
A: Psychologists, as well as experiment, have shown people do not produce random numbers--they don't even come close.  But there are ways to combine your efforts to produce sequences of numbers that are "more random" than either of you is likely to produce individually.
You and your wife can be modeled as "black boxes" that output numbers.  To simplify the analysis, we may either ask you both to output only zeros and ones, or else we may force that by rounding your outputs and reducing mod $2$ (that is, looking only at the parity).  As such, you each produce sequences of binary digits.
In order to make much progress, we have to ensure these sequences average 50% zeros and 50% ones in the long run.  People cannot do that on their own without undue mental burden.  Unless you are unwittingly regular in your production, though, the simple expedient of inverting every other output (turning a zero into a one and a one into a zero) will accomplish this.
Any black box that emits a sequence of bits can be used to emit a sequence of random integers within a given interval $0,1,\ldots,m-1$.  For instance, if you select a power of two for $m$, say $m=2^f$, you can just collect the output in non-overlapping blocks of $f$ bits and interpret them in binary.
In the following account, think of your output as forming the sequence $X$ and your wife's output as forming the sequence $Y$.
In his classic The Art of Computer Programming (Volume 2, section 3.2.2, Algorithm M) Donald Knuth explains

There are reasonably efficient ways to combine two sequences into a third one that should be haphazard enough to satisfy all but the most hardened skeptic.
Suppose we have two sequences $X_0, X_1, \ldots,$ and $Y_0, Y_1, \ldots$ of random numbers between $0$ and $m-1$, preferably generated by two unrelated methods.  Then we can, for example, use one random sequence to permute the leements of another, as suggested by M. D. MacLaren and G. Marsaglia [JACM 12 (1965), 83-89; see also Marsaglia and Bray, CACM 11 (1968), 757-759]:

Knuth proceeds to present "Algorithm M."  It is simple.  You fill a buffer array $V$ of size $k$ (to be selected according to your needs, often around $100$) with the first $k$ elements of $X$.  Subsequently, to generate a new random output, you take the next element of $Y$, use it to form a random index $j$ into $V$, output the number $V[j]$ located there, and replace it by the next element of $X$.
Knuth remarks,

On intuitive grounds it appears safe to predict that the sequence obtained by applying Algorithm M to [an example sequence] will satisfy virtually anyone's requirements for randomness in a computer-generated sequence, because the relationship between nearby terms of the output has been almost entirely obliterated.  Furthermore, the time required to generate this sequence is only slightly more than twice as long as it takes to generate the sequence $X$ alone.

When computers were much less capable than now and good random number generators were hard to come by (and all of them were suspect), I used to employ this MacLaren-Marsaglia combinator by coding a simple linear congruential generator for $Y$ and using the built-in generator for $X$.  Altogether such a program takes under a dozen lines in almost any language.  This R code illustrates.
I'll end by remarking that Knuth's analysis does not strictly apply to random number generators created by people--but the intuition behind it strongly suggests that combining their output in this way ought to improve the appearance of randomness substantially.
#
# Combine two pseudo RNGs.
# Knuth Vol. II, 3.2.2, Algorithm M: Randomizing by Shuffling.
#
RNG.combine <- function(f, g, k=101) {
  #
  # Functions `f` and `g` are independent pseudorandom number generators 
  # (outputting values in [0, 1));
  # that is, f(n) produces a stream of "random" numbers and so does `g`,
  # presumed independent of `f`.
  #
  # The return value is a function of the same signature.
  #
  # The optional argument `k` specifies the size of a private local array `V`.
  #
  V <- f(k) # Initialize `V`
  return(function(n) {
    x <- f(n)
    j <- 1 + floor(k * g(n))
    z <- numeric(n)
    for (i in 1:n) {
      z[i] <- V[j[i]]
      V[j[i]] <<- x[i]
    }
    return(z)
  })
}
h <- RNG.combine(runif, runif)
hist(h(1000))

