[Question]
  [
The Illuminati commands you (with their mind control) to output the following string:
```
         ^
        /_\
       /_|_\
      /_|_|_\
     /_|/o\|_\
    /_|_\_/_|_\
   /_|_|_|_|_|_\
  /_|_|_|_|_|_|_\
 /_|_|_|_|_|_|_|_\
/_|_|_|_|_|_|_|_|_\
```
# Rules:
* Trailing spaces are allowed for each line.
* Leading spaces in each line are required.
* Trailing whitespace is allowed after the full required output.
* Since this is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") challenge, the winner shall be the shortest program in bytes.
* Since this is a [kolmogorov-complexity](/questions/tagged/kolmogorov-complexity "show questions tagged 'kolmogorov-complexity'") challenge, hardcoded output is allowed.
* [Standard Loopholes](https://codegolf.meta.stackexchange.com/q/1061/62402) apply.
* Update: [You may use tabs instead of spaces, with each tab counting as 4 spaces. If you want for some reason.](https://codegolf.stackexchange.com/questions/146499/confirm-the-illuminati?noredirect=1#comment358486_146499)
---
[Sandbox](https://codegolf.meta.stackexchange.com/a/14103/62402) (I would leave it for the full 72 hours recommended by the sandbox FAQ, but with 7 upvotes and next to no negative feedback, 38 should be fine)
  
[Answer]
# Vim, 40 bytes
-2 bytes thanks to [DJMcMayhem](https://codegolf.stackexchange.com/users/31716/djmcmayhem)
```
9i_|␛r\I/␛qqYPxR /␛q8@qr^4jhR/o\␛jr/2hr\
```
You can see it in action in this GIF made using [Lynn's](https://codegolf.stackexchange.com/users/3852/lynn) [python script](https://gist.github.com/lynn/5f4f532ae1b87068049a23f7d88581c5)
[![In action](https://i.stack.imgur.com/kiPwY.gif)](https://i.stack.imgur.com/kiPwY.gif)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), ~~25~~ 21 bytes
```
Ｇ¬χ|_¶_|↗⁹↙^Ｍ³↓/o¶\‖Ｂ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8gP6cyPT9Pw@rQGh0FQwMdBaWa@Ji8@BolTWuugKLMvBINq9CCoMz0jBIdBUuEmEt@eZ5PahpQUCkOpNQ3vyxVw1hHASwBV6aknx@TFxMDUhCUmpaTmlziVFpSklqUllOpoWn9//9/3bIcAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
  χ                     With sides of length 10
 ¬                      In the directions down and left
Ｇ                       Draw a closed polygon (implicit side)
   |_¶_|                Filled with |_ and _| on alternate lines
        ↗⁹               Draw a line of 9 /s
          ↙^            Draw a ^ and move the cursor down and left
            Ｍ³↓         Move down 3 characters
               /o¶\     Print the left half of the eye
                   ‖Ｂ  Reflect the canvas keeping the right edge
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), 37 bytes
```
9i|_á\|r/òÄó_|
>òC ^4jhR/o\j2hR\_/
```
[Try it online!](https://tio.run/##K/v/3zKzJl768MKYmiL9w5sOtxzeHF/DZXd4k7NCnLRJVkaQfn6MdJZRRlBMvP7//wA "V – Try It Online")
Hexdump:
```
00000000: 3969 7c5f 1be1 5c7c 722f f2c4 f35f 7c0a  9i|_..\|r/..._|.
00000010: 3ef2 4320 5e1b 346a 6852 2f6f 5c1b 6a32  >.C ^.4jhR/o\.j2
00000020: 6852 5c5f 2f                             hR\_/
```
Explanation:
```
9i                              " Insert 9 copies of...
  |_                            "   '|_'
    <esc>                       " Return to normal mode
         á\                     " Append a backslash
           |                    " Move to the first character
            r/                  " Replace it with a forward slash
              ò                 " Recursively...
               Ä                "   Duplicate this line (upwards)
                ó               "   Remove one instance of..
                 _|             "     '_|'
>                               "   Indent this line with one space
 ò                              " End the loop
  C ^                           " Change this line (previously '/_\') to ' ^'
     <esc>                      " Return to normal mode
          4j                    " Move down 4 lines
            h                   " Move one character to the left
             R                  " Write this text over existing characters...
              /o\               "   '/o\'
                 <esc>          " Return to normal mode
                      j         " Move down a line
                       2h       " Move two characters to the left
                         R      " Write this text over existing characters...
                          \_/   " '\_/'
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), ~~31~~ ~~27~~ 25 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
 ^9∫Ƨ_|m└Κ}¹±§"/o¶\_”95žΓ
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTIwJTVFOSV1MjIyQiV1MDFBN18lN0NtJXUyNTE0JXUwMzlBJTdEJUI5JUIxJUE3JTIyL28lQjYlNUNfJXUyMDFEOTUldTAxN0UldTAzOTM_)
```
 ^                         push "^"
  9∫      }                do 9 times, pushing counter
    Ƨ_|                      push "_|"
       m                     mold that to the counter
        └Κ                   prepend "/"
           ¹               collect the lines in an array - ["^", "/_", "/_|", ..., "/_|_|_|_|_"]
            ±              reverse each                    ["^", "_/", "|_/", ..., "_|_|_|_|_/"]
             §             reverse as ascii-art:
                            ["         ^",
                             "        /_",
                             "       /_|",
                             ...,
                             "/_|_|_|_|_"]
              "/o¶\_”      push "/o
                                 \_"
                     95ž   insert that at [9; 5]
                        Γ  palindromize horizontally
```
or a 24 byte version using `¼` (space to an antidiagonal) instead of `±§`:
```
 ^9∫Ƨ_|m└Κ}¹¼"/o¶\_”95žΓ
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JTIwJTVFOSV1MjIyQiV1MDFBN18lN0NtJXUyNTE0JXUwMzlBJTdEJUI5JUJDJTIyL28lQjYlNUNfJXUyMDFEOTUldTAxN0UldTAzOTM_)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~103~~ ~~101~~ ~~98~~ 95 bytes
-2 bytes thanks to Jonathan Frech  
-3 bytes thanks to ovs  
```
for i in range(10):print(9-i)*' '+['^','/_%s\\'%['|_'*~-i,'|/o\|_','|_\_/_|_'][i%6/4*i%3]][i>0]
```
[Try it online!](https://tio.run/##Dce9DoMgFAbQV2Ehn1INVhuTOvgigDcd/LkLGOpiYnx1ZDtnP48t@DalJUTBgr2IP7/Oxbsphz2yP4pvzaWCwMtgQgVN8m8tpMFFUHfNFS4dbE4GWdKU6QzLXn8Uy85lj41L6QE "Python 2 – Try It Online")
[Answer]
# JavaScript (ES6), ~~95~~ 92 bytes
```
f=(n=9,s='')=>n--?f(n,s+' ')+s+`/${n-4?n-3?'_|'.repeat(n):'_|/o\\|':'_|_\\_/_|'}_\\
`:s+`^
`
```
Or **91 bytes** with a leading new-line -- which I think is not allowed:
```
f=(n=9,s=`
`)=>n--?f(n,s+' ')+s+`/${n-4?n-3?'_|'.repeat(n):'_|/o\\|':'_|_\\_/_|'}_\\`:s+`^`
```
### Demo
```
f=(n=9,s='')=>n--?f(n,s+' ')+s+`/${n-4?n-3?'_|'.repeat(n):'_|/o\\|':'_|_\\_/_|'}_\\
`:s+`^
`
O.innerText = f()
```
```
<pre id=O></pre>
```
### Formatted and commented
```
f = (n = 9, s = '') =>    // n = line counter, s = leading spaces
  n-- ?                   // if we haven't reached the top:
    f(n, s + ' ') +       //   do a recursive call with one more leading space
    s +                   //   append the leading spaces
    `/${                  //   append the left border
      n - 4 ?             //   if this is not the 4th row:
        n - 3 ?           //     if this is not the 3rd row:
          '_|'.repeat(n)  //       append the brick pattern
        :                 //     else (3rd row):
          '_|/o\\|'       //       append the top of the eye
      :                   //   else (4th row):
        '_|_\\_/_|'       //     append the bottom of the eye
    }_\\\n`               //   append the right border + line-feed
  :                       // else:
    s + `^\n`             //   append the top of the pyramid and stop the recursion
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~124~~ ~~122~~ ~~120~~ ~~119~~ ~~117~~ ~~115~~ 118 bytes
-1 byte thanks to @xanoetux
+3 missing the lowest level...
```
f(i){for(printf("%*c",i=10,94);--i;printf("\n%*c%s_\\",i,47,i^6?i^5?"_|_|_|_|_|_|_|_|_|"+i*2:"_|_\\_/_|":"_|/o\\|"));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z9NI1OzOi2/SKOgKDOvJE1DSVUrWUkn09bQQMfSRNNaVzfTGiYTkweUUy2Oj4kBKtAxMdfJjDOzz4wztVeKr0GHStqZWkZWIImYmHh9IB/E1s@PialR0tS0rv2fm5iZp6FZzaWgkKahac1V@x8A "C (gcc) – Try It Online")
[Answer]
## Haskell, ~~110~~ 107 bytes
```
"         ^\n"++do z<-[1..9];([z..8]>>" ")++'/':g z++"_\\\n"
g 4="_|/o\\|"
g 5="_|_\\_/_|"
g x=[2..x]>>"_|"
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzX0kBBuJi8pS0tVPyFapsdKMN9fQsY601oqv09Cxi7eyUFJQ0tbXV9dWt0hWqtLWV4mNigKq50hVMbJXia/TzY2JqQDxTEA8oF68fD@ZX2EYb6elVgAwACvzPTczMU7BVKCgtCS4pUkj7/y85LScxvfi/bnJBAQA "Haskell – Try It Online")
Those 9 space at the beginning hurt.
How it works
```
"         ^\n"++         -- first line, followed by
do                       -- we use the "do" syntatic sugar for monads,
                         -- here the list monad 
   z<-[1..9]             -- for all 'z' from [1..9] perform the following
                         -- and collect the results in a single list
     ([z..8]>>" ")++'/'  --   make the spaces for the current line and
                         --   the left wall '/'
     g z                 --   call g to make the inner part
     "_\\\n"             --   append '_', '\' and a NL
g 4="_|/o\\|"            -- line 4 and 5 are implemented directly
g 5="_|_\\_/_|"
g x=[2..x]>>"_|"         -- all other lines are some copies of "_|"
```
Edit: -3 bytes thanks to @Laikoni:
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~109~~ 105 bytes
```
filter f{' '*$_+'/'+'_|'*(8-$_)+'_\'}
' '*9+'^'
8|f
7|f
6|f
'     /_|/o\|_\
    /_|_\_/_|_\'
3..0|%{$_|f}
```
[Try it online!](https://tio.run/##LYlBCoMwFET3/xRZpIwaagRB7V1C/yqhhYCigot8zx5j6cAb3jDLfPh1@/gYcw7fuPtVhQSFRrOBhQELmmp6aq6LO5x0ny@DN2iSQGNhKEDdsSx2dsKO/osd/xrUt20nj6RZwpnzBQ "PowerShell – Try It Online")
*Saved 4 bytes thanks to Veskah.*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~47~~ ~~42~~ 40 bytes
```
'/„_|ûûû«η'^0ǝ.∞.C":;<IJK"Çv"/o\\_/"Nèyǝ
```
[Try it online!](https://tio.run/##MzBNTDJM/f9fXf9Rw7z4msO7QfDQ6nPb1eMMjs/Ve9QxT89ZycraxtPLW@lwe5mSfn5MTLy@kt/hFZXH5/7/DwA "05AB1E – Try It Online")
```
'/„_|ûûû«                                # Push bottom left tier of pyramid.
         η                               # All prefixes of...
          '^0ǝ                           # Replace the tip.
              .∞.C                       # Mirror, Center.
                  ":;<IJK"Ç              # Push [58,59,60,73,74,75].
                           v"/o\\_/"Nèyǝ # Replace those indexes with the eye.
```
---
Stupid version: `„_|3×"_|/o\|".;„_|2×û"_|_\_/_".;`
---
Other, less stupid version (but still worse):
# [05AB1E](https://github.com/Adriandmen/05AB1E), 42 bytes
```
•~µÎт•η4¾ǝ•Σ}•4ǝ•3x1•5ǝεS"|_/\^o"sèJ}€.∞.C
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcOiukNbD/ddbAKyzm03ObTv@FwQa3EtkDQBs40rDIGk6fG557YGK9XE68fE5SsVH17hVfuoaY3eo455es7//wMA "05AB1E – Try It Online")
[Answer]
# [Bubblegum](https://esolangs.org/wiki/Bubblegum), 48 bytes
```
00000000: 5380 8138 2e18 4b3f 3e86 0bce ac01 72e0  S..8..K?>.....r.
00000010: 6c30 0fc6 d1cf 8f01 71e1 cae2 218a e12a  l0......q...!..*
00000020: 6ba0 ea61 7c84 085c 0021 0417 4188 0100  k..a|..\.!..A...
```
[Try it online!](https://tio.run/##Lc6xDsIwDATQna84VgbLTtrUYgAxM7KyJMFhoAwgdePfQwI9yZN1z05LSrPdl2etvGaP0StDxSuciWJIvsCbBnDKhphZMDlj4EKkROfjgXretPkL0oyQPYNLDrhJLtDSS2KCHM3BiUaYuAjM/CvTq82WaLcarhspMiyG1sw6gHXMaBsBDzJhEFW0W@2PB1H8EF07cGpOrV8 "Bubblegum – Try It Online")
[Answer]
# PHP, 123+3 bytes
+3 bytes for the weird tab counting. (it still moves the cursor 8 spaces in any console!)
```
for($i=10;--$i;)$r.=str_pad(str_pad("
",$i)."/",20-$i,"_|")."\\";$r[48]=$r[65]="/";$r[50]=$r[63]="\\";$r[49]=o;echo"   ^$r";
```
Note: The first character after `echo"` is a tab character!
Run with `-nr` or [try it online](http://sandbox.onlinephpfunctions.com/code/fbab51e242680fef041c3acacfdaf015e546a126).
other version, same length:
```
for(;$i++<9;)$r.=str_pad(str_pad("
",10-$i)."/",10+$i,"_|")."\\";$r[48]=$r[65]="/";$r[50]=$r[63]="\\";$r[49]=o;echo"    ^$r";
```
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~79~~ 73 bytes
```
/8x
8
$*
+`^(.*)\Sx
 $1x¶$&
 x
 ^
/111x
/1/o\|x
/1111x
/1x_/1x
1
_|
x
_\
```
[Try it online!](https://tio.run/##K0otycxL/P@fS9@igsuCS0WLSzshTkNPSzMmuIJLQcWw4tA2FTUuBSA7jkvf0NCwAkjq58fUVIB5YG5FPBBzGXLF13BVcMXH/P8PAA "Retina – Try It Online")
[Answer]
# Ruby, 92 bytes
```
10.times{|i|s=' '*(10-i)+(i<1??^:"/#{"_|"*~-i}_\\");i/2==2&&s[9,3]="/o\\_/"[i%2*2,3];puts s}
```
[Answer]
# Excel VBA, 104 Bytes
Anonymous VBE immediate window function that confirms the truth.
**Version A:**
```
?Spc(9)"^":For i=0To 8:[A1]=i:?Spc(8-i)"/_"[If(A1=3,"|/o\|_",If(A1=4,"|_\_/_|_",Rept("|_",A1)))]"\":Next
```
**Version B:**
```
?Spc(9)"^":For i=0To 8:[A1]=i:?Spc(8-i)"/_"IIf(i=3,"|/o\|_",IIf(i=4,"|_\_/_|_",[Rept("|_",A1)]))"\":Next
```
[Answer]
# [Python 2](https://docs.python.org/2/), 154 bytes
```
l=bytearray
a,b=' _';g=[l(a*9+"^"+a*9)]+[l(a*(8-k)+"/%s\\"%"|".join(b*k+b))for k in range(9)]
g[4][8:11]=l("/o\\")
g[5][8:11]=l("\\_/")
for r in g:print r
```
[Try it online!](https://tio.run/##TcvRCoIwFIDhe59iHBA3Vw2jwIw9iTPZwKYpm5x2I/Tua3bV1Q8f/OsWRu/OMS7SbGHQiHrL9MHIgvTF3cp2obq8cXgAT2Ud/wGtjzPjIPK3UpDDB04vPzlqypkbxp4eyUwmR1A7O9B0Zba9dG3dVFUnFwrCp40lvP6hUr1IuM@4z7ZZcXKBYIxf "Python 2 – Try It Online")
-3 bytes using `bytearray` thanks to Rod  
-1 byte thanks to bobrobbob
[Answer]
# Javascript 90 bytes (if default parameter a=9 is required then 92 bytes)
```
A=(a,x=``)=>a?A(a-1,x+" ")+x+"/".padEnd(a*2,a^5?a^4?"_|":"_|/o\\|":"_|_\\_/")+`\\
`:x+`^
`
console.log(A(9))
```
[Answer]
# Java 8, 156 bytes
```
v->"".format("%1$9s^\n%1$8s/a%1$7s/ba%1$6s/bba     /b/o\\|a    /b_\\_/ba   /bbbbba  /bbbbbba /bbbbbbba/bbbbbbbba","").replace("a","_\\\n").replace("b","_|")
```
**Explanation:**
[Try it here.](https://tio.run/##TVBdawMhEHzvr1ikAYVG6Us/CO0/aF4KfalNWI0ppp4ep3cQmvz2y5q7QsFlZmeXZcYDDrhMrYuH3c9oA@YMb@jj7w2Aj8V1e7QO1rUFeC@dj99g@UfyOxjEitQzFb1csHgLa4jwAuOwfGVM7lPXYOFscX/7nDc6Ej5lhQSPWZmKD4QG62lQRiWtTzjxrdZbdZ3QgrnuTITYTAz@EYPsjjEhO9cGcstZ7emCjv9FU8UTE@Nqctz2JpDj2fhQEzUUnE8hP78AxZz6mItrZOqLbGlUeJSWxz4EMX/AebwA)
```
v->                        // Method with empty unused parameter and String return-type
  "".format(               //  Format the following String (`%1$Ns` = N spaces)
      "%1$9s^\n            //            ^
       %1$8s/a             //           /_\
       %1$7s/ba            //          /_|_\
       %1$6s/bba           //         /_|_|_\
            /b/o\\|a       //        /_|/o\|_\
           /b_\\_/ba       //       /_|_\_/_|_\
          /bbbbba          //      /_|_|_|_|_|_\
         /bbbbbba          //     /_|_|_|_|_|_|_\
        /bbbbbbba          //    /_|_|_|_|_|_|_|_\
       /bbbbbbbba","")     //   /_|_|_|_|_|_|_|_|_\
    .replace("a","_\\\n")  //  Replace all "a" with "_\" + new-line
    .replace("b","_|")     //  Replace all "b" with "_|"
                           // End of method (implicit / single-line return-statement)
```
[Answer]
# Julia, ~~152~~ ~~141~~ ~~139~~ ~~130~~ ~~127~~ ~~120~~ ~~113~~ 112 bytes
```
q="_|";a+b=" "^a*b;a\b=replace(a,q^3,q*b,1);~n=n<0?9+"^\n":~(n-1)*(8-n+"/$(q^n)_\\\n");print(~8\"/o\\|"\"_\\_/")
```
Explained:
```
#Define constant q to abbreviate this string
q="_|";
#Redefine the addition operator to compactly provide whitespace 
#where needed
a+b=" "^a*b;
#Redefine the inverse division operator so we can substitute 
#"_|_|_|" with "_|"*b very compactly
a\b=replace(a,q^3,q*b,1);
#Redefine the bitwise not operator to generate pyramid layers
#Defines them recursively, calling itself to generate previous 
#layers before appending its own. 
#The base case generates the tip. 
~n=n<0?9+"^\n":~(n-1)*(8-n+"/$(q^n)_\\\n");
#Print to output
print(
    #Pyramid with 8 body layers
    ~8
    #Then patch in the eye
    \"/o\\|"
    \"_\\_/"
)
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 174 153 bytes
```
()=>string.Format(@"{1,10}
{0,10}\
{0,9}{2}{3,10}{2}{0,7}|/o\{2}{3,8}\_/_{2}{0,5}{4}  {3}{4} {3}|_{4}{3}|_|_{4}","/_","^",@"|_\
","/_|_",@"|_|_|_|_|_\
")
```
[Try it online!](https://tio.run/##NY/BasMwDIbP01MIn2zImrRd6UbWUhj01MFgh11CTfDMMLQ22O5gOHr2zE4oAn2/PnSQVHhUzuvxFoz9wc@/EPW1BXXpQ8CPBCH20Sg83qx6DdHnnT165yLucORit5/d4uj8tY/8wNKyWjYEqSnoCl8orSity1xCU21pqF03y2fqZC1nv6H0RIhpPTFjkDlMnBKrWC1zO7PqwAbZwSQGOY/3ylqMLdwP/3XmG997Y7mABA9vzgZ30Ysvb6I@Gat5eYYL0QIBjf8 "C# (.NET Core) – Try It Online")
An inefficient way of building the pyramid, but interesting working through it.
### Acknowledgements
-21 bytes thanks to @someone
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 144 bytes
This one may seem quite boring, because it is quite boring.
```
()=>@"         ^
        /_\
       /z\
      /z|_\
     /_|/o\|_\
    /z\_/z\
   /z|z|z\
  /z|z|z|_\
 /z|z|z|z\
/z|z|z|z|_\".Replace("z","_|_")
```
[Try it online!](https://tio.run/##NY/NCgIhFEbX@RQXVwo1PsA0EQStCqIWbYZETEKYNNQJmp9nN6fGezfn@ziLe6VfSetUbL02D7h8fFDPEslGeA@nHvkggpawb41c@@CSswFnbYAKIqHVZoshzw1lYrzOzLqMrBtyzfjAbJ1jUvisJSfthH/6KTOmOlOqcXFWr0ZIRXCHl5gPHNNYonzv2@o7HIU2hKIeLXbWeNuo4up0UAdtFJl@IJSWaERj/AI "C# (.NET Core) – Try It Online")
[Answer]
# [Splinter](https://esolangs.org/wiki/Splinter), 124 bytes
```
H{\/}G{BB}F{\_DG}E{\ H}D{\\\
}C{A\|}B{\ \ }A{\_\|\_}GG\ \^\
GGHFBEADGBHCFE\_\|H\o\\\|FHA\\\_HADBECCADBHCCC\_DECCCADHCCCC\_\\
```
[Try it online!](https://deadfish.surge.sh/splinter#SHtcL31He0JCfUZ7XF9ER31Fe1wgSH1Ee1xcXAp9Q3tBXHx9QntcIFwgfUF7XF9cfFxffUdHXCBcXlwKR0dIRkJFQURHQkhDRkVcX1x8SFxvXFxcfEZIQVxcXF9IQURCRUNDQURCSENDQ1xfREVDQ0NBREhDQ0NDXF9cXA==)
[Answer]
# JavaScript, 117 bytes
I know for a *fact* I'm not beating any of the golfing languages, but at least I can give my own solution.
```
$=>[...Array(10)].map((e,i)=>' '.repeat(9-i)+(i--?`/${['_|/o\\|','_|_\\_/_|'][i-3]||'_|'.repeat(i)}_\\`:'^')).join`
`
```
Here's a demo:
```
var f = $=>[...Array(10)].map((e,i)=>' '.repeat(9-i)+(i--?`/${['_|/o\\|','_|_\\_/_|'][i-3]||'_|'.repeat(i)}_\\`:'^')).join`
`;
console.log(f());
console.log(f.toString().length);
```
Explanation:
```
$=>                                       // outer function start
[...Array(10)]                            // create an array to map
.map(…)                                   // map it
    (e,i)=>                               // mapping function start
    ' '.repeat(9-i)                       // spaces for padding
    +(i--?…:'^')                          // use the carat if at the top of the pyramid
        `/${…}_\\`                        // otherwise, make the sides + steps
            ['_|/o\\|','_|_\\_/_|'][i-3]  // use the patterns for the eye, if in the correct rows
            ||'_|'.repeat(i)              // otherwise, make the "bricks" structure
.join`
`                                         // join all the rows into a string (yes this part has a newline in it)
```
[Answer]
# Javascript, 238 bytes
My very first try at codegolfing :D
```
var f=()=>{let b=x=>' '.repeat(x),g='\\',h='/',i=1,st=[(b(9)+'^').split('')];for(;i<10;i++)st.push((b(9-i)+h+st.map(i=>'_').join('|')+g).split(''));st[4][8]=st[5][10]=h;st[4][9]='o';st[5][8]=st[4][10]=g;return st.map(s=>s.join('')).join('\n');}
document.getElementById("display").innerHTML = f();
console.log(f.toString().length);
```
```
<pre id="display">
</pre>
```
]