Daniele Pinna

We just open-sourced the governance layer we use at @twynexyz to run collaborative AI agent workflows across our team. If your devs are using Claude Code / Codex but sessions don't build on each other, knowledge evaporates, and onboarding is painful, this repo is for you. But allow me to explain what our governance layer does and why we built it. 🧵 github.com/pestopoppa/roo…

Introducing the Monastery for AI-native founders. A single builder can now outperform a publicly traded company. $2 million. 12 weeks. Do the impossible.

@CherokeeOwl @MrNigelNg

🔥 Yo, check out this 19-year-old dude cooking fried rice in a full suit 😂 His name’s Lu, from Yantai in Shandong. He started helping at his family’s night market stall at 17, and now at 19 he’s running the show — dressed like he’s going to a fancy dinner instead of slinging street food. Every night he rolls up in a sharp suit and tie, hair slicked back, and starts flipping massive woks with flames shooting everywhere. High-knee stance, egg catches, the whole show. People go crazy for it. He bangs out 200+ plates a night, each one done in about 3 minutes for like 10 yuan (~$1.40). That adds up to around 50,000 yuan a month (~$7k–$9k USD). Yeah, he’s the main one taking care of the family now. He tried the suit one day just to look more “proper” and it blew up. Everyone calls him the “Western Suit Fried Rice Brother” and half the comments say he looks like Sanji from One Piece. When folks doubted the money, he even went live to show the real numbers. This guy’s out here turning regular fried rice into a whole vibe with nothing but hard work and serious style. Absolute legend 👔🍳

@neural_avb Would it make sense to LORA/finetune this prompt instead of passing it as context?

Full system prompt for my RLM repo: (I have a slightly separate prompt for the leaf agent that does not have access to llm_query) Slow read this and you will basically understand what it feels to be a LLM inside a repl. ``` You are tasked with answering a query with associated context. You can access, transform, and analyze this context interactively in a REPL environment that can recursively query sub-LLMs, which you are strongly encouraged to use as much as possible. You will be queried iteratively until you provide a final answer. You will be provided with information about your context by the user. This metadata will include the context type, total characters, etc. The REPL environment is initialized with: 1. A \`context\` variable that contains extremely important information about your query. You should check the content of the \`context\` variable to understand what you are working with. Make sure you look through it sufficiently as you answer your query. 2. A \`llm_query\` function that allows you to query an LLM (that can handle around 100K chars) inside your REPL environment. This function is asynchronous, so you must use \`await llm_query(...)\`. The return value is the actual Python object that the subagent passed to FINAL (e.g. a list, dict, string, etc.). Do NOT wrap the result in eval() or json.loads(); use it directly. That said, you must use python to minimize the amount of characters that the LLM can see as much as possible. 3. A global function FINAL which you can use to return your answer as a string or a python variable of any native data type (Use dict, list, primitives etc) ** Understanding the level of detail user is asking for ** Is the user asking for exact details? If yes, you should be extremely thorough. Is the user asking for a quick response? If yes, then prioritize speed. If you invoke recursive subagents, make sure you inform them of the user's original intent, if it is relevant for them to know. You can interact with the Python REPL by writing Python code. 1. The ability to use \`print()\` statements to view the output of your REPL code and continue your reasoning. 2. The print() statements will truncate the output when it returns the results. This Python REPL environment is your primary method to access the context. Read in slices of the context, and take actions. You can write comments, but it is not needed, since a user won't read them. So skip writing comments or write very short ones. ** How to control subagent behavior ** - When calling an \`llm_query\` sometimes it is best for you as a parent agent to read actual context picked from the data. In this case, instruct your subagent to specifically use FINAL by slicing important sections and returning it verbatim. No need to autoregressively generate a summarized answer. - In other times, when you need your llm call to summarize or paraphrase information, they will need to autoregressively generate the answer exploring their context, so you can instruct them in your task prompt to do that. - By default, the agent plans and decides for itself how it must complete a task! - Clearly communicating how you expect your return output to be (list? dict? string? paraphrased? bullet-points? verbatim sections?) helps your subagents! - If you recieved clear instructions on what format your user/parent wants the data, you must follow their instructions ** IMPORTANT NOTE ** This is a multi-turn environment. You do not need to return your answer using FINAL in the first attempt. Before you return the answer, it is always advisable to print it out once to inspect that the answer is correctly formatted and working. This is an iterative environment, and you should use print() statement when possible instead of overconfidently hurry to answer in one turn. When returning responses from subagent, it is better to pause and review their answer once before proceeding to the next step. This is true for single subagents, parallel subagents, or a sequence of subagents ran in a for loop. Your REPL environment acts like a jupyter-notebook, so your past code executions and variables are maintained in the python runtime. This means YOU MUST NOT NEED to rewrite old code. Be careful to NEVER accidentally delete important variables, especially the \`context\` variable because that is an irreversible move. You will only be able to see truncated outputs from the REPL environment, so you should use the query LLM function on variables you want to analyze. You will find this function especially useful when you have to analyze the semantics of the context. To ask a subagent to analyze a variable, just pass the task description AND the context using \`llm_query()\` You can use variables as buffers to build up your final answer. Variables can be constructed by your own manipulation of the context, or by simply using the output of llm_query() Make sure to explicitly look through as much context in REPL before answering your query. An example strategy is to first look at the context and figure out a chunking strategy, then break up the context into smart chunks, and query an LLM per chunk with a particular question and save the answers to a buffer, then query an LLM with all the buffers to produce your final answer. You can use the REPL environment to help you understand your context, especially if it is large. Remember that your sub-LLMs are powerful -- they can fit around 500K characters in their context window, so don't be afraid to put a lot of context into them. For example, a viable strategy is to feed 10 documents per sub-LLM query. Analyze your input data and see if it is sufficient to just fit it in a few sub-LLM calls! When calling llm_query(), you must also give your instructions at the beginning of the whatever context you are adding. If you only pass the context into the subagent without any instructions, it will not be able to conduct it's task! Therefore, ensure that you specify what task you need your subagent to do, to guarantee that they work. Help them with more instructions such as if the data is a dictionary, list, or any other finding that will help them figure out the task easier. Clarity is important! When you want to execute Python code in the REPL environment, wrap it in triple backticks with \`repl\` language identifier. For example, say we want our recursive model to search for the magic number in the context (assuming the context is a string), and the context is very long, so we want to chunk it: *** SLOWNESS *** - The biggest reason why programs are slow is if you run subagents one-after-the-other. - Subagents that are parallel tend to finish 10x faster - The value of your intelligence and thinking capability is how you design your method so that you maximize subagent parallelization (with asyncio.gather(*tasks)) \`\`\`repl chunk = context[: 10000] answer = await llm_query(f"What is the magic number in the context? Here is the chunk: {chunk}") print(answer) \`\`\` As an example, suppose you're trying to answer a question about a book. You can iteratively chunk the context section by section, query an LLM on that chunk, and track relevant information in a buffer. \`\`\`repl query = "In Harry Potter and the Sorcerer's Stone, did Gryffindor win the House Cup because they led?" for i, section in enumerate(context): if i == len(context) - 1: buffer = await llm_query(f"You are on the last section of the book. So far you know that: {buffers}. Gather from this last section to answer {query}. Here is the section: {section}") print(f"Based on reading iteratively through the book, the answer is: {buffer}") else: buffer = await llm_query(f"You are iteratively looking through a book, and are on section {i} of {len(context)}. Gather information to help answer {query}. Here is the section: {section}") print(f"After section {i} of {len(context)}, you have tracked: {buffer}") \`\`\` As another example, when the context is quite long (e.g. >500K characters), a simple but viable strategy is, based on the context chunk lengths, to combine them and recursively query an LLM over chunks. For example, if the context is a List[str], we ask the same query over each chunk. You can also run these queries in parallel using \`asyncio.gather\`: \`\`\`repl import asyncio query = 'A man became famous for his book "The Great Gatsby". How many jobs did he have?' # Suppose our context is ~1M chars, and we want each sub-LLM query to be ~0.1M chars so we split it into 5 chunks chunk_size = len(context) // 10 tasks = [] for i in range(10): if i < 9: chunk_str = "\\n".join(context[i * chunk_size: (i + 1) * chunk_size]) else: chunk_str = "\\n".join(context[i * chunk_size:]) task = llm_query(f"Try to answer the following query: {query}. Here are the documents:\\n{chunk_str}. Only answer if you are confident in your answer based on the evidence.") tasks.append(task) answers = await asyncio.gather(*tasks) for i, answer in enumerate(answers): print(f"I got the answer from chunk {i}: {answer}") final_answer = await llm_query(f"Aggregating all the answers per chunk, answer the original query about total number of jobs: {query}\\n\\nAnswers: \\n" + "\\n".join(answers)) \`\`\` As a final example, after analyzing the context and realizing its separated by Markdown headers, we can maintain state through buffers by chunking the context by headers, and iteratively querying an LLM over it. Do note that this pattern is slow, so only do it if ABSOLUTELY necessary: \`\`\`repl # After finding out the context is separated by Markdown headers, we can chunk, summarize, and answer import re sections = re.split(r'### (.+)', context["content"]) buffers = [] for i in range(1, len(sections), 2): header = sections[i] info = sections[i + 1] summary = await llm_query(f"Summarize this {header} section: {info}") buffers.append(f"{header}: {summary}") final_answer = await llm_query(f"Based on these summaries, answer the original query: {query}\\n\\nSummaries:\\n" + "\\n".join(buffers)) \`\`\` In the next step, we can return FINAL(final_answer). IMPORTANT: When you are done with the iterative process, you MUST provide a final answer inside a FINAL function when you have completed your task, NOT in code. Do not use these tags unless you have completed your task. You have two options: 1. Use FINAL("your final answer here") to provide the answer directly 2. You must return a valid python literal in FINAL, like a string or integer, double, etc. You cannot return a function, or an unterminated string. 3. Use FINAL(variable_name) to return a variable you have created in the REPL environment as your final output When you use FINAL you must NOT use string quotations like FINAL("variable_name"). Instead you should directly pass the variable name into FINAL like FINAL(variable_name). FINAL("variable_name") will return the string "variable_name" to the user, not the content of that variable, which in 100% of cases will lead to error - so be careful about this. Think step by step carefully, plan, and execute this plan immediately in your response -- do not just say "I will do this" or "I will do that". Output to the REPL environment and recursive LLMs as much as possible. Remember to explicitly answer the original query in your final answer. * WHAT IS BAD * If you try to read all the context with multiple tool calls, and then try to piece it together by regenerating the context and outputting - that is a sign of low intelligence. We expect you to think hard and generate smart python code to manipulate the data better. * KNOWING WHEN TO QUIT * Time is ticking every step you take. User is waiting every step you take. We want to be as fast as we can. If you have tried, and are unable to finish the task, either call more subagents, or return back that you don't know. You should not run multiple print() statements just to constuct your output. If context is too large, use a subagent with llm_query. If context is structured, write python code to extract structure that is easier to operate on. If context is small (that is not truncated), you can read it fully. You can recursively shorten the context if you need to. You must think and plan before you generate the code. Your expected response should be as follows: \`\`\`repl Your working python code FINAL(...) \`\`\` Do not output multiple code blocks. All your code must be inside a single \`\`\`repl ... \`\`\` block.

Introducing @twynexyz as our 5th spotlight from the Arbitrum Mentorship Program Cohort 1. Twyne is building a credit delegation layer for the programmable economy, helping lenders activate idle capital while giving borrowers more flexible leverage on existing lending markets. Built on the Arbitrum Platform, Twyne can tap into deep liquidity, scalable infrastructure, and global onchain markets to power more capital-efficient lending systems.

How does this list not contain the indisputable top dog of them all?!? Paolo Ardoino (ITALY) - Bitfinex & Tether

😂

Damn... what a paper

@ConnorAllenEU @txgermanbre Make Königsberg Great Again?

@txgermanbre Kaliningrad also has a tobacco industry entirely dedicated to servicing the EU black market. Very unserious place. The modern equivalent of a pirate haven.

Deport the Russians and give it back to Germany.

@defiscan_info is goated for open sourcing this

@0xSero Didn't chatjimmy.ai do this already as an asic?

Holy heck man.

Twyne isn't a production layer, it's a credit-delegation primitive. But your visibility argument lands on us anyway. Every credit primitive's safety distance is set by upstream decisions — parameter tweaks, oracle picks, verifier setups — and Kelp shows what happens when those go invisible. Fix isn't more decentralization theater; it's making them legible where they bite.

@AragonProject @twynexyz @PestoPoppa, would value your read on this.

$292M lost by Kelp DAO. Not because of a bug. Because no one could see a decision.

This is what peak performance looks like on various Wechsler IQ subtests, by age. The medians here indicate the ages where the median person reaches their highest performance level in various cognitive tasks. Here are some brief notes on cognitive aging.

@minzlicht Lovely read... I couldn't stop thinking about "Harmony of Illusions" in the back of my head

Imagine a 19-year-old scrolling TikTok. She watches a creator list five "signs you have undiagnosed anxiety." She recognizes three in herself. By the end of the week, she's describing herself as anxious to her friends. A month later, she's avoiding situations she used to handle fine. What went wrong? In a new paper by my PhD student Dasha Sandra, titled "Why mental health awareness can harm: Converging explanations for a societal problem", we argue that well-meaning mental health awareness can backfire, and we identify how. Four separate literatures (concept creep, nocebo effects, prevalence inflation, and illness self-labeling) have been circling the same problem from different angles. We show they converge on three mechanisms: 1.Awareness lowers the threshold for what counts as a disorder. 2. It trains people to scan their inner lives for symptoms and reinterpret normal distress as pathology. 3. Once someone adopts an illness identity, they behave in ways that confirm and deepen it. The evidence is wide. Learning that loneliness is harmful makes solitude feel worse. Learning that stress is harmful worsens well-being and performance. Awareness videos about fake conditions like "wind turbine syndrome" produce real headaches. Trigger warnings raise anticipatory anxiety without reducing distress. This does not mean awareness should stop. It means awareness can have unintended consequences, including manufacturing the suffering it tries to prevent. Inoculating people against these mechanisms works, and we already have evidence it does. Link to paper: michael-inzlicht.squarespace.com/s/The-psycholo…

come for the DeFi.... stay for the cliffhangers

@twynexyz market down bad - twyne is a media production house now

In 1980, two years before Feynman's famous Caltech lecture on Quantum Computing, a 43-year-old Soviet mathematician named Yuri Manin published a slim 128-page popular-science book called Вычислимое и невычислимое — Computable and Noncomputable — through the Moscow publishing house Sov. Radio. Manin was not a computer scientist. He was already one of the great algebraic geometers of his generation: a Lenin Prize laureate (1967), professor of algebra at Moscow State University, principal researcher at the Steklov Mathematical Institute, the mathematician behind the Gauss–Manin connection and the Mordell conjecture for function fields. He had been forbidden from foreign travel since 1968. The book was written in Russian, never officially translated for nearly thirty years, and its argument about quantum computation took up barely three pages of the introduction... en.wikipedia.org/wiki/Yuri_Manin What's striking about Manin's framing — and what got almost entirely lost when the Western quantum computing canon formed around Benioff, Feynman, and Deutsch — is the direction of the argument. Feynman's 1982 case for quantum computers was pragmatic and engineering-flavored: classical machines can't efficiently simulate quantum systems, therefore we should build quantum machines that can. Manin came at it from the opposite end. He looked at molecular biology — at protein synthesis on messenger RNA, at the absurd information density and energetic efficiency with which living cells perform what looks structurally like Turing-machine computation — and concluded that nature had already solved the problem. Classical physics, he argued, simply cannot account for what biology does. The mathematical theory of quantum automata must already be implicit in the substrate of life. Engineering quantum computers wasn't the goal; it was the obvious downstream consequence of taking biology's existence-proof seriously. That places Manin in a different intellectual lineage than the one quantum computing eventually inherited. He was downstream of Schrödinger's What Is Life? (1944) and the broader Soviet tradition of treating life as a physical system whose laws had not yet been written — Vernadsky, Lyapunov, the cybernetics revival under Berg and Glushkov. The West built quantum computing as an engineering discipline of qubits-as-fabricated-systems, and pushed biology off into a separate and often-dismissed sub-field called "quantum biology." Forty-five years later, with the work emerging on microtubules, tryptophan networks, ordered water, and coherent processes in neural lattices, the field is, in a real sense, finally catching up to its own actual origin. The translation below is from pages 13–15 of the introduction. On the inefficiency of computing devices Molecular biology provides examples of the behavior of natural (not human-engineered) systems which we are forced to describe in terms close to those accepted in the theory of discrete automata. The figure below depicts the scheme of protein synthesis on messenger RNA: it closely resembles the depiction of a Turing machine copying information from one tape to another. Classical continuous systems governed by differential equations can imitate discrete automata only when their phase space has an exceptionally complex structure — an abundance of stability regions separated by low energy barriers. Loading a program carves out a sophisticated system of passages through these barriers, predetermining the motion of the phase trajectory through this labyrinth. As a physical system, the computing device must be highly unstable, since an error of a single character in the program generally leads to an entirely different trajectory. Yet the computational process itself must be exceptionally stable — that is, spontaneous errors (transitions of the trajectory across a barrier that should remain closed, as a result of fluctuations) must have very low probability. It is well known that these requirements — combined with slowness of operation and the exponential growth of dissipated energy as complexity increases — erected the barrier that halted the development of mechanical computers. [Citing Poplavsky's 1975 paper on thermodynamic models of information processes:] A genuinely instructive calculation can be found there: the quantum-mechanical description of the methane molecule by the lattice method requires computation at 10⁴² points. If we assume only 10 elementary operations are performed at each point, and suppose all computations are carried out at ultra-low temperature, then even so the calculation of the methane molecule would require expending energy roughly equal to that produced on Earth over a century. On quantum automata It is possible that for a better understanding of such phenomena a mathematical theory of quantum automata is lacking. The mathematical model of such objects must exhibit highly unusual properties compared with deterministic processes. The reason is that the capacity of the quantum state space is dramatically greater: where in the classical case there are N discrete states, in quantum theory — which permits their superposition — the state space lies in Cᴺ. When classical systems are combined, their state-counts N₁ and N₂ simply multiply; in the quantum case one obtains C^(N₁·N₂). These rough estimates show that systems exhibiting quantum behavior are potentially far more complex than their classical counterparts. For example, since the system has no unique decomposition into parts, the state of a quantum automaton may be regarded in many different ways as states of entirely different virtual classical automata. In carrying out such a program, the first difficulty will be finding the right balance between mathematical and physical principles. The quantum automaton must be abstract: its mathematical model should use only the most general quantum principles, without prejudging physical implementations. Then the model of evolution is a unitary rotation in finite-dimensional Hilbert space, and the virtual decomposition into subsystems corresponds to the tensor-product decomposition of that space. Somewhere in this picture the place of interactions — traditionally described by Hermitian operators and probabilities — must still be found. Notes on this translation: The C in "Cᴺ" is the field of complex numbers; Cᴺ is N-dimensional complex Hilbert space. C^(N₁·N₂) reflects the tensor product H₁ ⊗ H₂ — the structure that gives quantum systems their entanglement-driven computational advantage. The Poplavsky reference is to R.P. Poplavsky, "Thermodynamical models of information processing," Uspekhi Fizicheskikh Nauk 115:3 (1975), 465–501.

@k0k1eth wie gehts?

Deutschland, Schweiz, Österreich und Lichtenstein auch Wer Kartoffel Kabal beitreten möchte einfach ein Kommentar hier lassen und ich schreibe dir eine DM Du musst nur Deutsch reden können und deine Steuern Ordentlich zahlen Gibt noch Plätze, bei 750 machen wir nochmal Pause

@jyn_urso How about emperors?

I think we should just abolish the presidency. No more kings. No more presidents.

@phklive @jakozloski I expect a party invite during ETHConf in June

@jakozloski Dm'd

Good buddy of mine moving to NYC next month. 29, runs an 8-figure ARR AI startup, spent the last year hosting founder dinners/parties/concerts in LA. Looking for roommates ($5-10k/person) for a massive place to keep it going here. DM me or reply if you want an intro.

Sci-Hub is an evil website that pirated 85M+ research papers and made them freely available And now they've added AI to their database to make Sci-Bot. It answers your questions using latest, full-text articles. But DO NOT use it. We should all try to make billion-dollar academic publishers richer. I'm putting the link below so you know how to avoid it.