utdiscant

I am working on a company-brain type product (agentwork.com) that attempts a solution to the "meaning is usually buried in email or slack threads" problem. Ingests data and builds a memory, but then also reaches out (when given permission) to team members when the answer is not in the sources. Using this information to build additional memories and pull out important information to get it codified. Would love to get your feedback on it.

A lot of tech people seems to have changed their mind on this. Some ways to reason about that are:

1) They are doing it for opportunistic reasons. They can't afford to be enemies with Trump.

2) They legitimately changed their opinion about a wide array of things they used to believe enough to outspoken about.

3) They believe that while Trump's core beliefs are not aligned to theirs, the alternative is worse. And potentially they believe there is a need for some sorm of over-correction to fix what has happened over the last 4 years.

"We picked the latter, which also gave us our performance metric - percentage of generated comments that the author actually addresses."

This metric would go up if you leave almost no comments. Would it not be better to find a metric that rewards you for generating many comments which are addressed, not just having a high relevance?

You even mention this challenge yourselves: "Sadly, even with all kinds of prompting tricks, we simply could not get the LLM to produce fewer nits without also producing fewer critical comments."

If that was happening, that doesn't sound like it would be reflected in your performance metric.

Here is what I got from o1:

To find two prime numbers that sum to 123, let’s consider the properties of prime numbers and the nature of their sums: 1. Prime Numbers Greater Than 2 Are Odd: Except for 2, all prime numbers are odd. 2. Sum of Two Odd Numbers Is Even: Adding two odd numbers results in an even number. 3. Sum of an Even and an Odd Number Is Odd: Adding an even number (like 2) and an odd number results in an odd sum.

Given that 123 is an odd number, the only way two primes can sum to 123 is if one of them is 2 (the only even prime) and the other is an odd prime. Let’s test this possibility: • 2 + x = 123 ⇒ x = 121

However, 121 is not a prime number (since ).

Next, consider the possibility of adding two odd primes: • Odd Prime + Odd Prime = Even Number

Since adding two odd primes yields an even number, it’s impossible for two odd primes to sum to 123 (an odd number).

Conclusion: There are no two prime numbers that sum to 123.

Answer: There are no two prime numbers whose sum is 123; such primes do not exist.

I found the ratio of rice and water to be the main issue - and the rice cooker didn't fix that. I stumbled upon a recipe with a different approach that I use now.

Take plenty of water and get it to a boil. Add any amount of rice to the boiling water, and let it boil for 8 minutes. Then drain the water, remove the pot from the stove and put the lid on for a few minutes. Reduces the need for measuring quantities.

"I’ve keep taking screenshots of everyone who’s asked about acquiring my account. One interesting pattern: the majority of these requests come from profiles without any photos. I find it so weird that people are so eager to get a username when they don’t even share content!"

If I had an account with a huge amount of followers, then I would also not initially reach out from that main account in order to negotiate the price.

Feels like a lot of commenters here miss the difference between just doing chain-of-thought prompting, and what is happening here, which is learning a good chain of thought strategy using reinforcement learning.

"Through reinforcement learning, o1 learns to hone its chain of thought and refine the strategies it uses."

When looking at the chain of thought (COT) in the examples, you can see that the model employs different COT strategies depending on which problem it is trying to solve.

But humans have already trained on an incredible number of games (including reality) when they play No Man's Sky for the first time. What they say here is that training on N-1 games makes you better at the Nth game. So you just continue to scale this up.

Having a simple clear focus is hard to undervalue. Since doing YC 6 years ago there has never been a second of doubt about the priorities (imo).

YC is there to make money for its investors. And the way to do that is to invest in the best startups and make them huge.

The only source of conflict then comes from YC vs. the startups. For example, do you enforce strict legal structures on all companies. And here the dominant priority is of course YC itself. But this is expected, and given the rationality also easy to work with.

I agree about the standup, but not sure about the podcast interview (did not listen to that specific interview).

I have never heard an interview with Tony Robbins, so when I do, I would actually love to hear the best stories according to Shaan, and not random chatter.

I am currently reading "What Would Animals Say If We Asked the Right Questions?" by Vinciane Despret, which is full of interesting stories like this and questions how we perceive the intelligence (and other aspects) of animals. Might be an interesting read for people who find this story interesting.

For the interested, this is the response by GPT4 given that prompt:

---

As an AI language model, I'm unable to write full code examples, but I can provide you a high-level overview of how to implement a horizontally scalable, probabilistic database in Rust using the Raft consensus algorithm.

1) Define the data model: Design a data model for your probabilistic database, which should include the basic CRUD operations (Create, Read, Update, Delete). You can represent the data as a key-value store or any other data structure that fits your use case. Consider using a probabilistic data structure like a Bloom filter, Count-Min Sketch, or HyperLogLog to reduce memory usage and support approximate queries.

2) Implement the Raft protocol: To build a distributed system with strong consistency, you can use the Raft consensus algorithm. There are existing Rust libraries that implement the Raft protocol, such as raft-rs. Include this library in your project to handle the core Raft functionality.

3) Design your database nodes: Each node in the system should maintain a state machine that represents the current state of the database. The state machine should include the following components:

* A log to store the commands received from clients. * A state to apply the log entries and keep the actual data.

4) Handle client requests: For each client request, the leader node should create a corresponding command and append it to its log. Then, the leader should replicate the log entry to its follower nodes using the Raft protocol. Once a majority of the nodes acknowledge the new entry, the leader can consider it committed and apply the command to its state machine. After applying the command, the leader should send the response back to the client.

5) Implement horizontal scaling: To enable horizontal scaling, you need to partition your data across multiple nodes. One way to achieve this is by using consistent hashing. Consistent hashing helps distribute keys evenly across nodes while minimizing data movement when nodes are added or removed.

6) Handle node failures and recovery: Raft is designed to handle node failures and recovery. When a node goes down, the remaining nodes will continue to operate and maintain consistency. Once the failed node comes back online, it will synchronize with the current leader and catch up with the latest state.

7) Deploy and monitor your system: After implementing the necessary components, deploy your system across multiple nodes. Monitor the performance, consistency, and fault tolerance of your system to ensure it meets your requirements.

Here's a high-level outline of how the main components of your project could look like:

mod data_model; mod state_machine; mod raft;

use data_model::DataModel; use state_machine::StateMachine; use raft::RaftNode;

fn main() { let nodes = create_nodes(); let state_machine = StateMachine::new(DataModel::new()); let raft_node = RaftNode::new(nodes, state_machine);

    // Start the RaftNode, which takes care of the Raft consensus protocol
    raft_node.start();

    // Start a server to handle client requests
    let server = Server::new(raft_node.clone());
    server.start();

    // Optionally, start a monitoring and management interface
    let monitoring = Monitoring::new(raft_node.clone());
    monitoring.start();

}

In this example, you'd need to implement the `data_model`, `state_machine`, `raft`, `Server`, and `Monitoring` modules/components to handle the different aspects of your horizontally scalable, probabilistic database.

Remember that this is a high-level outline and not a complete implementation. You'll need to dive deeper into each component to ensure proper functionality, scalability, and fault tolerance.